dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/animation/animation-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441
 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/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471
 472
 473 // add here SWIG version check
 474
 475 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 476 // disable Swig-dependent warnings
 477
 478 // 'identifier1' has C-linkage specified,
 479 // but returns UDT 'identifier2' which is incompatible with C
 480 #pragma warning(disable: 4190)
 481
 482 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 483 #pragma warning(disable: 4800)
 484
 485 // debug info too long etc etc
 486 #pragma warning(disable: 4786)
 487 #endif
 488
 489
 490 #include <stdexcept>
 491
 492
 493 #include <string>
 494
 495
 496 #include <vector>
 497 #include <algorithm>
 498 #include <stdexcept>
 499
 500
 501 #include <map>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <utility>
 507
 508
 509 typedef float floatp;
 510
 511 SWIGINTERN floatp *new_floatp(){
 512   return new float();
 513 }
 514 SWIGINTERN void delete_floatp(floatp *self){
 515   if (self) delete self;
 516 }
 517 SWIGINTERN void floatp_assign(floatp *self,float value){
 518   *self = value;
 519 }
 520 SWIGINTERN float floatp_value(floatp *self){
 521   return *self;
 522 }
 523 SWIGINTERN float *floatp_cast(floatp *self){
 524   return self;
 525 }
 526 SWIGINTERN floatp *floatp_frompointer(float *t){
 527   return (floatp *) t;
 528 }
 529
 530 typedef int intp;
 531
 532 SWIGINTERN intp *new_intp(){
 533   return new int();
 534 }
 535 SWIGINTERN void delete_intp(intp *self){
 536   if (self) delete self;
 537 }
 538 SWIGINTERN void intp_assign(intp *self,int value){
 539   *self = value;
 540 }
 541 SWIGINTERN int intp_value(intp *self){
 542   return *self;
 543 }
 544 SWIGINTERN int *intp_cast(intp *self){
 545   return self;
 546 }
 547 SWIGINTERN intp *intp_frompointer(int *t){
 548   return (intp *) t;
 549 }
 550
 551 typedef double doublep;
 552
 553 SWIGINTERN doublep *new_doublep(){
 554   return new double();
 555 }
 556 SWIGINTERN void delete_doublep(doublep *self){
 557   if (self) delete self;
 558 }
 559 SWIGINTERN void doublep_assign(doublep *self,double value){
 560   *self = value;
 561 }
 562 SWIGINTERN double doublep_value(doublep *self){
 563   return *self;
 564 }
 565 SWIGINTERN double *doublep_cast(doublep *self){
 566   return self;
 567 }
 568 SWIGINTERN doublep *doublep_frompointer(double *t){
 569   return (doublep *) t;
 570 }
 571
 572 typedef unsigned int uintp;
 573
 574 SWIGINTERN uintp *new_uintp(){
 575   return new unsigned int();
 576 }
 577 SWIGINTERN void delete_uintp(uintp *self){
 578   if (self) delete self;
 579 }
 580 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 581   *self = value;
 582 }
 583 SWIGINTERN unsigned int uintp_value(uintp *self){
 584   return *self;
 585 }
 586 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 587   return self;
 588 }
 589 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 590   return (uintp *) t;
 591 }
 592
 593 typedef unsigned short ushortp;
 594
 595 SWIGINTERN ushortp *new_ushortp(){
 596   return new unsigned short();
 597 }
 598 SWIGINTERN void delete_ushortp(ushortp *self){
 599   if (self) delete self;
 600 }
 601 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 602   *self = value;
 603 }
 604 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 605   return *self;
 606 }
 607 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 608   return self;
 609 }
 610 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 611   return (ushortp *) t;
 612 }
 613
 614 unsigned int int_to_uint(int x) {
 615    return (unsigned int) x;
 616 }
 617
 618
 619 using namespace Dali;
 620 using namespace Dali::Toolkit;
 621
 622 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 623
 624      // C++ code. DALi uses Handle <-> Body design pattern.
 625      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 626      // Handles in DALi can be converted into a boolean type
 627      // to check if the handle has a valid body attached to it.
 628      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 629      if( *self )
 630      {
 631        return true;
 632      }
 633      else
 634      {
 635        return false;
 636      }
 637     }
 638 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 639
 640      // C++ code. Check if two handles reference the same implemtion
 641      if( *self == rhs)
 642      {
 643        return true;
 644      }
 645      else
 646      {
 647        return false;
 648      }
 649     }
 650 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 651      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 652    }
 653 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){
 654      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 655    }
 656 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 657         std::vector< Dali::TouchPoint >* pv = 0;
 658         if (capacity >= 0) {
 659           pv = new std::vector< Dali::TouchPoint >();
 660           pv->reserve(capacity);
 661        } else {
 662           throw std::out_of_range("capacity");
 663        }
 664        return pv;
 665       }
 666 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 667         if (index>=0 && index<(int)self->size())
 668           return (*self)[index];
 669         else
 670           throw std::out_of_range("index");
 671       }
 672 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 673         if (index>=0 && index<(int)self->size())
 674           return (*self)[index];
 675         else
 676           throw std::out_of_range("index");
 677       }
 678 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 679         if (index>=0 && index<(int)self->size())
 680           (*self)[index] = val;
 681         else
 682           throw std::out_of_range("index");
 683       }
 684 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 685         self->insert(self->end(), values.begin(), values.end());
 686       }
 687 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 688         if (index < 0)
 689           throw std::out_of_range("index");
 690         if (count < 0)
 691           throw std::out_of_range("count");
 692         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 693           throw std::invalid_argument("invalid range");
 694         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 695       }
 696 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 697         if (index>=0 && index<(int)self->size()+1)
 698           self->insert(self->begin()+index, x);
 699         else
 700           throw std::out_of_range("index");
 701       }
 702 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 703         if (index>=0 && index<(int)self->size()+1)
 704           self->insert(self->begin()+index, values.begin(), values.end());
 705         else
 706           throw std::out_of_range("index");
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 709         if (index>=0 && index<(int)self->size())
 710           self->erase(self->begin() + index);
 711         else
 712           throw std::out_of_range("index");
 713       }
 714 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 715         if (index < 0)
 716           throw std::out_of_range("index");
 717         if (count < 0)
 718           throw std::out_of_range("count");
 719         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 720           throw std::invalid_argument("invalid range");
 721         self->erase(self->begin()+index, self->begin()+index+count);
 722       }
 723 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 724         if (count < 0)
 725           throw std::out_of_range("count");
 726         return new std::vector< Dali::TouchPoint >(count, value);
 727       }
 728 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 729         std::reverse(self->begin(), self->end());
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 732         if (index < 0)
 733           throw std::out_of_range("index");
 734         if (count < 0)
 735           throw std::out_of_range("count");
 736         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 737           throw std::invalid_argument("invalid range");
 738         std::reverse(self->begin()+index, self->begin()+index+count);
 739       }
 740 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 741         if (index < 0)
 742           throw std::out_of_range("index");
 743         if (index+values.size() > self->size())
 744           throw std::out_of_range("index");
 745         std::copy(values.begin(), values.end(), self->begin()+index);
 746       }
 747 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 748          return self->Empty();
 749       }
 750 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 751         return self->GetConnectionCount();
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 754           self->Connect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Disconnect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 760           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 761 /*@SWIG@*/ self->Emit( arg );
 762       }
 763 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 764          return self->Empty();
 765       }
 766 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767         return self->GetConnectionCount();
 768       }
 769 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 770           self->Connect( func );
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Disconnect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 776           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 777 /*@SWIG@*/ self->Emit( arg );
 778       }
 779 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 780          return self->Empty();
 781       }
 782 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){
 783         return self->GetConnectionCount();
 784       }
 785 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 *)){
 786           self->Connect( func );
 787       }
 788 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 *)){
 789           self->Disconnect( func );
 790       }
 791 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){
 792           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 793 /*@SWIG@*/ self->Emit( arg );
 794       }
 795 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 796          return self->Empty();
 797       }
 798 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799         return self->GetConnectionCount();
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 802           self->Connect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Disconnect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 808           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 809 /*@SWIG@*/ self->Emit( arg );
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 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){
 828          return self->Empty();
 829       }
 830 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){
 831         return self->GetConnectionCount();
 832       }
 833 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 &)){
 834         self->Connect( func );
 835       }
 836 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 &)){
 837         self->Disconnect( func );
 838       }
 839 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){
 840         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg1, arg2 );
 842       }
 843 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){
 844          return self->Empty();
 845       }
 846 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){
 847         return self->GetConnectionCount();
 848       }
 849 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 &)){
 850         self->Connect( func );
 851       }
 852 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 &)){
 853         self->Disconnect( func );
 854       }
 855 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){
 856         return self->Emit( arg1, arg2 );
 857       }
 858 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){
 859          return self->Empty();
 860       }
 861 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){
 862         return self->GetConnectionCount();
 863       }
 864 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 &)){
 865         self->Connect( func );
 866       }
 867 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 &)){
 868         self->Disconnect( func );
 869       }
 870 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){
 871         return self->Emit( arg1, arg2 );
 872       }
 873 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){
 874          return self->Empty();
 875       }
 876 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){
 877         return self->GetConnectionCount();
 878       }
 879 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 &)){
 880         self->Connect( func );
 881       }
 882 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 &)){
 883         self->Disconnect( func );
 884       }
 885 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){
 886         return self->Emit( arg1, arg2 );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 895           self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 901           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 905          return self->Empty();
 906       }
 907 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){
 908         return self->GetConnectionCount();
 909       }
 910 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 &)){
 911           self->Connect( func );
 912       }
 913 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 &)){
 914           self->Disconnect( func );
 915       }
 916 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){
 917           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 918 /*@SWIG@*/ self->Emit( arg );
 919       }
 920 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 921          return self->Empty();
 922       }
 923 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){
 924         return self->GetConnectionCount();
 925       }
 926 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 &)){
 927           self->Connect( func );
 928       }
 929 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 &)){
 930           self->Disconnect( func );
 931       }
 932 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){
 933           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 934 /*@SWIG@*/ self->Emit( arg );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 937          return self->Empty();
 938       }
 939 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){
 940         return self->GetConnectionCount();
 941       }
 942 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 &)){
 943           self->Connect( func );
 944       }
 945 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 &)){
 946           self->Disconnect( func );
 947       }
 948 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){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 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){
 953          return self->Empty();
 954       }
 955 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){
 956         return self->GetConnectionCount();
 957       }
 958 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 &)){
 959         self->Connect( func );
 960       }
 961 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 &)){
 962         self->Disconnect( func );
 963       }
 964 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){
 965         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg1, arg2 );
 967       }
 968 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){
 969          return self->Empty();
 970       }
 971 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){
 972         return self->GetConnectionCount();
 973       }
 974 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 &)){
 975         self->Connect( func );
 976       }
 977 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 &)){
 978         self->Disconnect( func );
 979       }
 980 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){
 981         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg1, arg2 );
 983       }
 984 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){
 985          return self->Empty();
 986       }
 987 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){
 988         return self->GetConnectionCount();
 989       }
 990 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 &)){
 991         self->Connect( func );
 992       }
 993 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 &)){
 994         self->Disconnect( func );
 995       }
 996 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){
 997         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg1, arg2 );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1001          return self->Empty();
1002       }
1003 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1004         return self->GetConnectionCount();
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1007           self->Connect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1010           self->Disconnect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1013           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg );
1015       }
1016 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1017          return self->Empty();
1018       }
1019 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1020         return self->GetConnectionCount();
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1023           self->Connect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1026           self->Disconnect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1029           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg );
1031       }
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1039           return self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1042           self->Disconnect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1045           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1047       }
1048
1049 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1050          return self->Empty();
1051       }
1052 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1053         return self->GetConnectionCount();
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1056           self->Connect( func );
1057       }
1058 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1059           self->Disconnect( func );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1062           return self->Emit();
1063       }
1064
1065 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1066         std::vector< unsigned int >* pv = 0;
1067         if (capacity >= 0) {
1068           pv = new std::vector< unsigned int >();
1069           pv->reserve(capacity);
1070        } else {
1071           throw std::out_of_range("capacity");
1072        }
1073        return pv;
1074       }
1075 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1076         if (index>=0 && index<(int)self->size())
1077           return (*self)[index];
1078         else
1079           throw std::out_of_range("index");
1080       }
1081 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1082         if (index>=0 && index<(int)self->size())
1083           return (*self)[index];
1084         else
1085           throw std::out_of_range("index");
1086       }
1087 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1088         if (index>=0 && index<(int)self->size())
1089           (*self)[index] = val;
1090         else
1091           throw std::out_of_range("index");
1092       }
1093 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1094         self->insert(self->end(), values.begin(), values.end());
1095       }
1096 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1097         if (index < 0)
1098           throw std::out_of_range("index");
1099         if (count < 0)
1100           throw std::out_of_range("count");
1101         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1102           throw std::invalid_argument("invalid range");
1103         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1104       }
1105 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1106         if (index>=0 && index<(int)self->size()+1)
1107           self->insert(self->begin()+index, x);
1108         else
1109           throw std::out_of_range("index");
1110       }
1111 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1112         if (index>=0 && index<(int)self->size()+1)
1113           self->insert(self->begin()+index, values.begin(), values.end());
1114         else
1115           throw std::out_of_range("index");
1116       }
1117 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1118         if (index>=0 && index<(int)self->size())
1119           self->erase(self->begin() + index);
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1124         if (index < 0)
1125           throw std::out_of_range("index");
1126         if (count < 0)
1127           throw std::out_of_range("count");
1128         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1129           throw std::invalid_argument("invalid range");
1130         self->erase(self->begin()+index, self->begin()+index+count);
1131       }
1132 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1133         if (count < 0)
1134           throw std::out_of_range("count");
1135         return new std::vector< unsigned int >(count, value);
1136       }
1137 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1138         std::reverse(self->begin(), self->end());
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1141         if (index < 0)
1142           throw std::out_of_range("index");
1143         if (count < 0)
1144           throw std::out_of_range("count");
1145         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1146           throw std::invalid_argument("invalid range");
1147         std::reverse(self->begin()+index, self->begin()+index+count);
1148       }
1149 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1150         if (index < 0)
1151           throw std::out_of_range("index");
1152         if (index+values.size() > self->size())
1153           throw std::out_of_range("index");
1154         std::copy(values.begin(), values.end(), self->begin()+index);
1155       }
1156 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1157         return std::find(self->begin(), self->end(), value) != self->end();
1158       }
1159 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1160         int index = -1;
1161         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1162         if (it != self->end())
1163           index = (int)(it - self->begin());
1164         return index;
1165       }
1166 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1167         int index = -1;
1168         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1169         if (rit != self->rend())
1170           index = (int)(self->rend() - 1 - rit);
1171         return index;
1172       }
1173 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1174         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1175         if (it != self->end()) {
1176           self->erase(it);
1177           return true;
1178         }
1179         return false;
1180       }
1181 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){
1182         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1183         if (capacity >= 0) {
1184           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1185           pv->reserve(capacity);
1186        } else {
1187           throw std::out_of_range("capacity");
1188        }
1189        return pv;
1190       }
1191 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){
1192         if (index>=0 && index<(int)self->size())
1193           return (*self)[index];
1194         else
1195           throw std::out_of_range("index");
1196       }
1197 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){
1198         if (index>=0 && index<(int)self->size())
1199           return (*self)[index];
1200         else
1201           throw std::out_of_range("index");
1202       }
1203 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){
1204         if (index>=0 && index<(int)self->size())
1205           (*self)[index] = val;
1206         else
1207           throw std::out_of_range("index");
1208       }
1209 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){
1210         self->insert(self->end(), values.begin(), values.end());
1211       }
1212 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){
1213         if (index < 0)
1214           throw std::out_of_range("index");
1215         if (count < 0)
1216           throw std::out_of_range("count");
1217         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1218           throw std::invalid_argument("invalid range");
1219         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1220       }
1221 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){
1222         if (index>=0 && index<(int)self->size()+1)
1223           self->insert(self->begin()+index, x);
1224         else
1225           throw std::out_of_range("index");
1226       }
1227 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){
1228         if (index>=0 && index<(int)self->size()+1)
1229           self->insert(self->begin()+index, values.begin(), values.end());
1230         else
1231           throw std::out_of_range("index");
1232       }
1233 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){
1234         if (index>=0 && index<(int)self->size())
1235           self->erase(self->begin() + index);
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 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){
1240         if (index < 0)
1241           throw std::out_of_range("index");
1242         if (count < 0)
1243           throw std::out_of_range("count");
1244         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1245           throw std::invalid_argument("invalid range");
1246         self->erase(self->begin()+index, self->begin()+index+count);
1247       }
1248 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){
1249         if (count < 0)
1250           throw std::out_of_range("count");
1251         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1252       }
1253 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){
1254         std::reverse(self->begin(), self->end());
1255       }
1256 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){
1257         if (index < 0)
1258           throw std::out_of_range("index");
1259         if (count < 0)
1260           throw std::out_of_range("count");
1261         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1262           throw std::invalid_argument("invalid range");
1263         std::reverse(self->begin()+index, self->begin()+index+count);
1264       }
1265 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){
1266         if (index < 0)
1267           throw std::out_of_range("index");
1268         if (index+values.size() > self->size())
1269           throw std::out_of_range("index");
1270         std::copy(values.begin(), values.end(), self->begin()+index);
1271       }
1272 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1273         std::vector< Dali::Actor >* pv = 0;
1274         if (capacity >= 0) {
1275           pv = new std::vector< Dali::Actor >();
1276           pv->reserve(capacity);
1277        } else {
1278           throw std::out_of_range("capacity");
1279        }
1280        return pv;
1281       }
1282 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1283         if (index>=0 && index<(int)self->size())
1284           return (*self)[index];
1285         else
1286           throw std::out_of_range("index");
1287       }
1288 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1289         if (index>=0 && index<(int)self->size())
1290           return (*self)[index];
1291         else
1292           throw std::out_of_range("index");
1293       }
1294 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1295         if (index>=0 && index<(int)self->size())
1296           (*self)[index] = val;
1297         else
1298           throw std::out_of_range("index");
1299       }
1300 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1301         self->insert(self->end(), values.begin(), values.end());
1302       }
1303 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1304         if (index < 0)
1305           throw std::out_of_range("index");
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1309           throw std::invalid_argument("invalid range");
1310         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1311       }
1312 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1313         if (index>=0 && index<(int)self->size()+1)
1314           self->insert(self->begin()+index, x);
1315         else
1316           throw std::out_of_range("index");
1317       }
1318 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1319         if (index>=0 && index<(int)self->size()+1)
1320           self->insert(self->begin()+index, values.begin(), values.end());
1321         else
1322           throw std::out_of_range("index");
1323       }
1324 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1325         if (index>=0 && index<(int)self->size())
1326           self->erase(self->begin() + index);
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1331         if (index < 0)
1332           throw std::out_of_range("index");
1333         if (count < 0)
1334           throw std::out_of_range("count");
1335         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1336           throw std::invalid_argument("invalid range");
1337         self->erase(self->begin()+index, self->begin()+index+count);
1338       }
1339 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1340         if (count < 0)
1341           throw std::out_of_range("count");
1342         return new std::vector< Dali::Actor >(count, value);
1343       }
1344 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1345         std::reverse(self->begin(), self->end());
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1348         if (index < 0)
1349           throw std::out_of_range("index");
1350         if (count < 0)
1351           throw std::out_of_range("count");
1352         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1353           throw std::invalid_argument("invalid range");
1354         std::reverse(self->begin()+index, self->begin()+index+count);
1355       }
1356 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1357         if (index < 0)
1358           throw std::out_of_range("index");
1359         if (index+values.size() > self->size())
1360           throw std::out_of_range("index");
1361         std::copy(values.begin(), values.end(), self->begin()+index);
1362       }
1363 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1364          return self->Empty();
1365       }
1366 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1367         return self->GetConnectionCount();
1368       }
1369 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 &)){
1370           self->Connect( func );
1371       }
1372 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 &)){
1373           self->Disconnect( func );
1374       }
1375 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){
1376           return self->Emit( arg );
1377       }
1378 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){
1379          return self->Empty();
1380       }
1381 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){
1382         return self->GetConnectionCount();
1383       }
1384 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)){
1385         self->Connect( func );
1386       }
1387 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)){
1388         self->Disconnect( func );
1389       }
1390 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){
1391         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1392 /*@SWIG@*/ self->Emit( arg1, arg2 );
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1395          return self->Empty();
1396       }
1397 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){
1398         return self->GetConnectionCount();
1399       }
1400 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)){
1401         self->Connect( func );
1402       }
1403 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)){
1404         self->Disconnect( func );
1405       }
1406 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){
1407         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1408 /*@SWIG@*/ self->Emit( arg1, arg2 );
1409       }
1410 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1411          return self->Empty();
1412       }
1413 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1414         return self->GetConnectionCount();
1415       }
1416 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)){
1417         self->Connect( func );
1418       }
1419 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)){
1420         self->Disconnect( func );
1421       }
1422 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){
1423         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1424 /*@SWIG@*/ self->Emit( arg1, arg2 );
1425       }
1426 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){
1427          return self->Empty();
1428       }
1429 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){
1430         return self->GetConnectionCount();
1431       }
1432 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)){
1433         self->Connect( func );
1434       }
1435 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)){
1436         self->Disconnect( func );
1437       }
1438 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){
1439         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1440 /*@SWIG@*/ self->Emit( arg1, arg2 );
1441       }
1442 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1443          return self->Empty();
1444       }
1445 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1446         return self->GetConnectionCount();
1447       }
1448 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)){
1449           self->Connect( func );
1450       }
1451 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)){
1452           self->Disconnect( func );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1455           return self->Emit( arg );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464           self->Connect( func );
1465       }
1466 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)){
1467           self->Disconnect( func );
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1470           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg );
1472       }
1473 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){
1474          return self->Empty();
1475       }
1476 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){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480           return self->Connect( func );
1481       }
1482 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)){
1483           self->Disconnect( func );
1484       }
1485 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){
1486           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1488       }
1489 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1490          return self->Empty();
1491       }
1492 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496           self->Connect( func );
1497       }
1498 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)){
1499           self->Disconnect( func );
1500       }
1501 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1502           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1503 /*@SWIG@*/ self->Emit( arg );
1504       }
1505 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){
1506          return self->Empty();
1507       }
1508 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){
1509         return self->GetConnectionCount();
1510       }
1511 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)){
1512           return self->Connect( func );
1513       }
1514 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)){
1515           self->Disconnect( func );
1516       }
1517 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){
1518           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1519 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1520       }
1521 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){
1522          return self->Empty();
1523       }
1524 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){
1525         return self->GetConnectionCount();
1526       }
1527 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 &)){
1528           self->Connect( func );
1529       }
1530 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 &)){
1531           self->Disconnect( func );
1532       }
1533 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){
1534           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1535 /*@SWIG@*/ self->Emit( arg );
1536       }
1537 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1538          return self->Empty();
1539       }
1540 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){
1541         return self->GetConnectionCount();
1542       }
1543 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 &)){
1544           self->Connect( func );
1545       }
1546 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 &)){
1547           self->Disconnect( func );
1548       }
1549 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){
1550           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1551 /*@SWIG@*/ self->Emit( arg );
1552       }
1553
1554
1555 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){
1556          return self->Empty();
1557       }
1558 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){
1559         return self->GetConnectionCount();
1560       }
1561 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 &)){
1562         self->Connect( func );
1563       }
1564 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 &)){
1565         self->Disconnect( func );
1566       }
1567 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){
1568         return self->Emit( arg1, arg2 );
1569       }
1570 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1571          return self->Empty();
1572       }
1573 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1574         return self->GetConnectionCount();
1575       }
1576 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)){
1577           self->Connect( func );
1578       }
1579 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)){
1580           self->Disconnect( func );
1581       }
1582 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1583           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1584 /*@SWIG@*/ self->Emit( arg );
1585       }
1586 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1587          return self->Empty();
1588       }
1589 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1590         return self->GetConnectionCount();
1591       }
1592 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 &)){
1593           self->Connect( func );
1594       }
1595 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 &)){
1596           self->Disconnect( func );
1597       }
1598 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){
1599           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1600 /*@SWIG@*/ self->Emit( arg );
1601       }
1602 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1603          return self->Empty();
1604       }
1605 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){
1606         return self->GetConnectionCount();
1607       }
1608 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)){
1609         self->Connect( func );
1610       }
1611 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)){
1612         self->Disconnect( func );
1613       }
1614 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){
1615         return self->Emit( arg1, arg2 );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1618          return self->Empty();
1619       }
1620 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){
1621         return self->GetConnectionCount();
1622       }
1623 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)){
1624         self->Connect( func );
1625       }
1626 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)){
1627         self->Disconnect( func );
1628       }
1629 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){
1630         return self->Emit( arg1, arg2 );
1631       }
1632
1633
1634 /* ---------------------------------------------------
1635  * C++ director class methods
1636  * --------------------------------------------------- */
1637
1638 #include "dali_wrap.h"
1639
1640 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1641   swig_init_callbacks();
1642 }
1643
1644 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1645
1646 }
1647
1648
1649 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1650   int jdepth  ;
1651
1652   if (!swig_callbackOnStageConnection) {
1653     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1654     return;
1655   } else {
1656     jdepth = depth;
1657     swig_callbackOnStageConnection(jdepth);
1658   }
1659 }
1660
1661 void SwigDirector_ViewImpl::OnStageDisconnection() {
1662   if (!swig_callbackOnStageDisconnection) {
1663     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1664     return;
1665   } else {
1666     swig_callbackOnStageDisconnection();
1667   }
1668 }
1669
1670 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1671   void * jchild = 0 ;
1672
1673   if (!swig_callbackOnChildAdd) {
1674     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1675     return;
1676   } else {
1677     jchild = (Dali::Actor *) &child;
1678     swig_callbackOnChildAdd(jchild);
1679   }
1680 }
1681
1682 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1683   void * jchild = 0 ;
1684
1685   if (!swig_callbackOnChildRemove) {
1686     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1687     return;
1688   } else {
1689     jchild = (Dali::Actor *) &child;
1690     swig_callbackOnChildRemove(jchild);
1691   }
1692 }
1693
1694 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1695   int jindex  ;
1696   void * jpropertyValue  ;
1697
1698   if (!swig_callbackOnPropertySet) {
1699     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1700     return;
1701   } else {
1702     jindex = index;
1703     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1704     swig_callbackOnPropertySet(jindex, jpropertyValue);
1705   }
1706 }
1707
1708 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1709   void * jtargetSize = 0 ;
1710
1711   if (!swig_callbackOnSizeSet) {
1712     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1713     return;
1714   } else {
1715     jtargetSize = (Dali::Vector3 *) &targetSize;
1716     swig_callbackOnSizeSet(jtargetSize);
1717   }
1718 }
1719
1720 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1721   void * janimation = 0 ;
1722   void * jtargetSize = 0 ;
1723
1724   if (!swig_callbackOnSizeAnimation) {
1725     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1726     return;
1727   } else {
1728     janimation = (Dali::Animation *) &animation;
1729     jtargetSize = (Dali::Vector3 *) &targetSize;
1730     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1731   }
1732 }
1733
1734 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1735   bool c_result = SwigValueInit< bool >() ;
1736   unsigned int jresult = 0 ;
1737   void * jarg0 = 0 ;
1738
1739   if (!swig_callbackOnTouchEvent) {
1740     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1741   } else {
1742     jarg0 = (Dali::TouchEvent *) &event;
1743     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1744     c_result = jresult ? true : false;
1745   }
1746   return c_result;
1747 }
1748
1749 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1750   bool c_result = SwigValueInit< bool >() ;
1751   unsigned int jresult = 0 ;
1752   void * jarg0 = 0 ;
1753
1754   if (!swig_callbackOnHoverEvent) {
1755     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1756   } else {
1757     jarg0 = (Dali::HoverEvent *) &event;
1758     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1759     c_result = jresult ? true : false;
1760   }
1761   return c_result;
1762 }
1763
1764 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1765   bool c_result = SwigValueInit< bool >() ;
1766   unsigned int jresult = 0 ;
1767   void * jarg0 = 0 ;
1768
1769   if (!swig_callbackOnKeyEvent) {
1770     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1771   } else {
1772     jarg0 = (Dali::KeyEvent *) &event;
1773     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1774     c_result = jresult ? true : false;
1775   }
1776   return c_result;
1777 }
1778
1779 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1780   bool c_result = SwigValueInit< bool >() ;
1781   unsigned int jresult = 0 ;
1782   void * jarg0 = 0 ;
1783
1784   if (!swig_callbackOnWheelEvent) {
1785     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1786   } else {
1787     jarg0 = (Dali::WheelEvent *) &event;
1788     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1789     c_result = jresult ? true : false;
1790   }
1791   return c_result;
1792 }
1793
1794 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1795   void * jsize = 0 ;
1796   void * jcontainer = 0 ;
1797
1798   if (!swig_callbackOnRelayout) {
1799     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1800     return;
1801   } else {
1802     jsize = (Dali::Vector2 *) &size;
1803     jcontainer = (Dali::RelayoutContainer *) &container;
1804     swig_callbackOnRelayout(jsize, jcontainer);
1805   }
1806 }
1807
1808 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1809   int jpolicy  ;
1810   int jdimension  ;
1811
1812   if (!swig_callbackOnSetResizePolicy) {
1813     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1814     return;
1815   } else {
1816     jpolicy = (int)policy;
1817     jdimension = (int)dimension;
1818     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1819   }
1820 }
1821
1822 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1823   Dali::Vector3 c_result ;
1824   void * jresult = 0 ;
1825
1826   if (!swig_callbackGetNaturalSize) {
1827     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1828   } else {
1829     jresult = (void *) swig_callbackGetNaturalSize();
1830     if (!jresult) {
1831       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1832       return c_result;
1833     }
1834     c_result = *(Dali::Vector3 *)jresult;
1835   }
1836   return c_result;
1837 }
1838
1839 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1840   float c_result = SwigValueInit< float >() ;
1841   float jresult = 0 ;
1842   void * jchild = 0 ;
1843   int jdimension  ;
1844
1845   if (!swig_callbackCalculateChildSize) {
1846     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1847   } else {
1848     jchild = (Dali::Actor *) &child;
1849     jdimension = (int)dimension;
1850     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1851     c_result = (float)jresult;
1852   }
1853   return c_result;
1854 }
1855
1856 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1857   float c_result = SwigValueInit< float >() ;
1858   float jresult = 0 ;
1859   float jwidth  ;
1860
1861   if (!swig_callbackGetHeightForWidth) {
1862     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1863   } else {
1864     jwidth = width;
1865     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1866     c_result = (float)jresult;
1867   }
1868   return c_result;
1869 }
1870
1871 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1872   float c_result = SwigValueInit< float >() ;
1873   float jresult = 0 ;
1874   float jheight  ;
1875
1876   if (!swig_callbackGetWidthForHeight) {
1877     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1878   } else {
1879     jheight = height;
1880     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1881     c_result = (float)jresult;
1882   }
1883   return c_result;
1884 }
1885
1886 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1887   bool c_result = SwigValueInit< bool >() ;
1888   unsigned int jresult = 0 ;
1889   int jdimension  ;
1890
1891   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1892     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1893   } else {
1894     jdimension = (int)dimension;
1895     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1896     c_result = jresult ? true : false;
1897   }
1898   return c_result;
1899 }
1900
1901 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1902   int jdimension  ;
1903
1904   if (!swig_callbackOnCalculateRelayoutSize) {
1905     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1906     return;
1907   } else {
1908     jdimension = (int)dimension;
1909     swig_callbackOnCalculateRelayoutSize(jdimension);
1910   }
1911 }
1912
1913 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1914   float jsize  ;
1915   int jdimension  ;
1916
1917   if (!swig_callbackOnLayoutNegotiated) {
1918     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1919     return;
1920   } else {
1921     jsize = size;
1922     jdimension = (int)dimension;
1923     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1924   }
1925 }
1926
1927 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1928   return Dali::CustomActorImpl::GetExtension();
1929 }
1930
1931 void SwigDirector_ViewImpl::OnInitialize() {
1932   if (!swig_callbackOnInitialize) {
1933     Dali::Toolkit::Internal::Control::OnInitialize();
1934     return;
1935   } else {
1936     swig_callbackOnInitialize();
1937   }
1938 }
1939
1940 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1941   void * jchild = 0 ;
1942
1943   if (!swig_callbackOnControlChildAdd) {
1944     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1945     return;
1946   } else {
1947     jchild = (Dali::Actor *) &child;
1948     swig_callbackOnControlChildAdd(jchild);
1949   }
1950 }
1951
1952 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1953   void * jchild = 0 ;
1954
1955   if (!swig_callbackOnControlChildRemove) {
1956     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1957     return;
1958   } else {
1959     jchild = (Dali::Actor *) &child;
1960     swig_callbackOnControlChildRemove(jchild);
1961   }
1962 }
1963
1964 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1965   void * jstyleManager  ;
1966   int jchange  ;
1967
1968   if (!swig_callbackOnStyleChange) {
1969     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1970     return;
1971   } else {
1972     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1973     jchange = (int)change;
1974     swig_callbackOnStyleChange(jstyleManager, jchange);
1975   }
1976 }
1977
1978 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1979   bool c_result = SwigValueInit< bool >() ;
1980   unsigned int jresult = 0 ;
1981
1982   if (!swig_callbackOnAccessibilityActivated) {
1983     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1984   } else {
1985     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1986     c_result = jresult ? true : false;
1987   }
1988   return c_result;
1989 }
1990
1991 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1992   bool c_result = SwigValueInit< bool >() ;
1993   unsigned int jresult = 0 ;
1994   void * jgesture  ;
1995
1996   if (!swig_callbackOnAccessibilityPan) {
1997     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1998   } else {
1999     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2000     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2001     c_result = jresult ? true : false;
2002   }
2003   return c_result;
2004 }
2005
2006 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2007   bool c_result = SwigValueInit< bool >() ;
2008   unsigned int jresult = 0 ;
2009   void * jtouchEvent = 0 ;
2010
2011   if (!swig_callbackOnAccessibilityTouch) {
2012     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2013   } else {
2014     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2015     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2016     c_result = jresult ? true : false;
2017   }
2018   return c_result;
2019 }
2020
2021 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2022   bool c_result = SwigValueInit< bool >() ;
2023   unsigned int jresult = 0 ;
2024   unsigned int jisIncrease  ;
2025
2026   if (!swig_callbackOnAccessibilityValueChange) {
2027     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2028   } else {
2029     jisIncrease = isIncrease;
2030     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2031     c_result = jresult ? true : false;
2032   }
2033   return c_result;
2034 }
2035
2036 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2037   bool c_result = SwigValueInit< bool >() ;
2038   unsigned int jresult = 0 ;
2039
2040   if (!swig_callbackOnAccessibilityZoom) {
2041     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2042   } else {
2043     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2044     c_result = jresult ? true : false;
2045   }
2046   return c_result;
2047 }
2048
2049 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2050   if (!swig_callbackOnKeyInputFocusGained) {
2051     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2052     return;
2053   } else {
2054     swig_callbackOnKeyInputFocusGained();
2055   }
2056 }
2057
2058 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2059   if (!swig_callbackOnKeyInputFocusLost) {
2060     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2061     return;
2062   } else {
2063     swig_callbackOnKeyInputFocusLost();
2064   }
2065 }
2066
2067 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2068   Dali::Actor c_result ;
2069   void * jresult = 0 ;
2070   void * jcurrentFocusedActor  ;
2071   int jdirection  ;
2072   unsigned int jloopEnabled  ;
2073
2074   if (!swig_callbackGetNextKeyboardFocusableActor) {
2075     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2076   } else {
2077     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2078     jdirection = (int)direction;
2079     jloopEnabled = loopEnabled;
2080     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2081     if (!jresult) {
2082       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2083       return c_result;
2084     }
2085     c_result = *(Dali::Actor *)jresult;
2086   }
2087   return c_result;
2088 }
2089
2090 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2091   void * jcommitedFocusableActor  ;
2092
2093   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2094     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2095     return;
2096   } else {
2097     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2098     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2099   }
2100 }
2101
2102 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2103   bool c_result = SwigValueInit< bool >() ;
2104   unsigned int jresult = 0 ;
2105
2106   if (!swig_callbackOnKeyboardEnter) {
2107     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2108   } else {
2109     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2110     c_result = jresult ? true : false;
2111   }
2112   return c_result;
2113 }
2114
2115 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2116   void * jpinch = 0 ;
2117
2118   if (!swig_callbackOnPinch) {
2119     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2120     return;
2121   } else {
2122     jpinch = (Dali::PinchGesture *) &pinch;
2123     swig_callbackOnPinch(jpinch);
2124   }
2125 }
2126
2127 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2128   void * jpan = 0 ;
2129
2130   if (!swig_callbackOnPan) {
2131     Dali::Toolkit::Internal::Control::OnPan(pan);
2132     return;
2133   } else {
2134     jpan = (Dali::PanGesture *) &pan;
2135     swig_callbackOnPan(jpan);
2136   }
2137 }
2138
2139 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2140   void * jtap = 0 ;
2141
2142   if (!swig_callbackOnTap) {
2143     Dali::Toolkit::Internal::Control::OnTap(tap);
2144     return;
2145   } else {
2146     jtap = (Dali::TapGesture *) &tap;
2147     swig_callbackOnTap(jtap);
2148   }
2149 }
2150
2151 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2152   void * jlongPress = 0 ;
2153
2154   if (!swig_callbackOnLongPress) {
2155     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2156     return;
2157   } else {
2158     jlongPress = (Dali::LongPressGesture *) &longPress;
2159     swig_callbackOnLongPress(jlongPress);
2160   }
2161 }
2162
2163 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2164   void * jslotObserver = 0 ;
2165   void * jcallback = 0 ;
2166
2167   if (!swig_callbackSignalConnected) {
2168     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2169     return;
2170   } else {
2171     jslotObserver = (void *) slotObserver;
2172     jcallback = (void *) callback;
2173     swig_callbackSignalConnected(jslotObserver, jcallback);
2174   }
2175 }
2176
2177 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2178   void * jslotObserver = 0 ;
2179   void * jcallback = 0 ;
2180
2181   if (!swig_callbackSignalDisconnected) {
2182     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2183     return;
2184   } else {
2185     jslotObserver = (void *) slotObserver;
2186     jcallback = (void *) callback;
2187     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2188   }
2189 }
2190
2191 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2192   return Dali::Toolkit::Internal::Control::GetControlExtension();
2193 }
2194
2195 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) {
2196   swig_callbackOnStageConnection = callbackOnStageConnection;
2197   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2198   swig_callbackOnChildAdd = callbackOnChildAdd;
2199   swig_callbackOnChildRemove = callbackOnChildRemove;
2200   swig_callbackOnPropertySet = callbackOnPropertySet;
2201   swig_callbackOnSizeSet = callbackOnSizeSet;
2202   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2203   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2204   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2205   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2206   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2207   swig_callbackOnRelayout = callbackOnRelayout;
2208   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2209   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2210   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2211   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2212   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2213   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2214   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2215   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2216   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2217   swig_callbackOnInitialize = callbackOnInitialize;
2218   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2219   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2220   swig_callbackOnStyleChange = callbackOnStyleChange;
2221   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2222   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2223   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2224   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2225   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2226   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2227   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2228   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2229   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2230   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2231   swig_callbackOnPinch = callbackOnPinch;
2232   swig_callbackOnPan = callbackOnPan;
2233   swig_callbackOnTap = callbackOnTap;
2234   swig_callbackOnLongPress = callbackOnLongPress;
2235   swig_callbackSignalConnected = callbackSignalConnected;
2236   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2237 }
2238
2239 void SwigDirector_ViewImpl::swig_init_callbacks() {
2240   swig_callbackOnStageConnection = 0;
2241   swig_callbackOnStageDisconnection = 0;
2242   swig_callbackOnChildAdd = 0;
2243   swig_callbackOnChildRemove = 0;
2244   swig_callbackOnPropertySet = 0;
2245   swig_callbackOnSizeSet = 0;
2246   swig_callbackOnSizeAnimation = 0;
2247   swig_callbackOnTouchEvent = 0;
2248   swig_callbackOnHoverEvent = 0;
2249   swig_callbackOnKeyEvent = 0;
2250   swig_callbackOnWheelEvent = 0;
2251   swig_callbackOnRelayout = 0;
2252   swig_callbackOnSetResizePolicy = 0;
2253   swig_callbackGetNaturalSize = 0;
2254   swig_callbackCalculateChildSize = 0;
2255   swig_callbackGetHeightForWidth = 0;
2256   swig_callbackGetWidthForHeight = 0;
2257   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2258   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2259   swig_callbackOnCalculateRelayoutSize = 0;
2260   swig_callbackOnLayoutNegotiated = 0;
2261   swig_callbackOnInitialize = 0;
2262   swig_callbackOnControlChildAdd = 0;
2263   swig_callbackOnControlChildRemove = 0;
2264   swig_callbackOnStyleChange = 0;
2265   swig_callbackOnAccessibilityActivated = 0;
2266   swig_callbackOnAccessibilityPan = 0;
2267   swig_callbackOnAccessibilityTouch = 0;
2268   swig_callbackOnAccessibilityValueChange = 0;
2269   swig_callbackOnAccessibilityZoom = 0;
2270   swig_callbackOnKeyInputFocusGained = 0;
2271   swig_callbackOnKeyInputFocusLost = 0;
2272   swig_callbackGetNextKeyboardFocusableActor = 0;
2273   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2274   swig_callbackOnKeyboardEnter = 0;
2275   swig_callbackOnPinch = 0;
2276   swig_callbackOnPan = 0;
2277   swig_callbackOnTap = 0;
2278   swig_callbackOnLongPress = 0;
2279   swig_callbackSignalConnected = 0;
2280   swig_callbackSignalDisconnected = 0;
2281 }
2282
2283 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2284   swig_init_callbacks();
2285 }
2286
2287 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2288
2289 }
2290
2291
2292 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2293   unsigned int c_result = SwigValueInit< unsigned int >() ;
2294   unsigned int jresult = 0 ;
2295
2296   if (!swig_callbackGetNumberOfItems) {
2297     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2298   } else {
2299     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2300     c_result = (unsigned int)jresult;
2301   }
2302   return c_result;
2303 }
2304
2305 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2306   Dali::Actor c_result ;
2307   void * jresult = 0 ;
2308   unsigned int jitemId  ;
2309
2310   if (!swig_callbackNewItem) {
2311     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2312   } else {
2313     jitemId = itemId;
2314     jresult = (void *) swig_callbackNewItem(jitemId);
2315     if (!jresult) {
2316       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2317       return c_result;
2318     }
2319     c_result = *(Dali::Actor *)jresult;
2320   }
2321   return c_result;
2322 }
2323
2324 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2325   unsigned int jitemId  ;
2326   void * jactor  ;
2327
2328   if (!swig_callbackItemReleased) {
2329     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2330     return;
2331   } else {
2332     jitemId = itemId;
2333     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2334     swig_callbackItemReleased(jitemId, jactor);
2335   }
2336 }
2337
2338 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2339   return Dali::Toolkit::ItemFactory::GetExtension();
2340 }
2341
2342 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2343   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2344   swig_callbackNewItem = callbackNewItem;
2345   swig_callbackItemReleased = callbackItemReleased;
2346 }
2347
2348 void SwigDirector_ItemFactory::swig_init_callbacks() {
2349   swig_callbackGetNumberOfItems = 0;
2350   swig_callbackNewItem = 0;
2351   swig_callbackItemReleased = 0;
2352 }
2353
2354 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2355   swig_init_callbacks();
2356 }
2357
2358 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2359
2360 }
2361
2362
2363 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2364   Dali::Actor c_result ;
2365   void * jresult = 0 ;
2366   void * jcurrent  ;
2367   void * jproposed  ;
2368   int jdirection  ;
2369
2370   if (!swig_callbackGetNextFocusableActor) {
2371     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2372   } else {
2373     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2374     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2375     jdirection = (int)direction;
2376     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2377     if (!jresult) {
2378       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2379       return c_result;
2380     }
2381     c_result = *(Dali::Actor *)jresult;
2382   }
2383   return c_result;
2384 }
2385
2386 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2387   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2388 }
2389
2390 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2391   swig_callbackGetNextFocusableActor = 0;
2392 }
2393
2394
2395 #ifdef __cplusplus
2396 extern "C" {
2397 #endif
2398
2399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2400   void * jresult ;
2401   floatp *result = 0 ;
2402
2403   {
2404     try {
2405       result = (floatp *)new_floatp();
2406     } catch (std::out_of_range& e) {
2407       {
2408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2409       };
2410     } catch (std::exception& e) {
2411       {
2412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2413       };
2414     } catch (...) {
2415       {
2416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2417       };
2418     }
2419   }
2420   jresult = (void *)result;
2421   return jresult;
2422 }
2423
2424
2425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2426   floatp *arg1 = (floatp *) 0 ;
2427
2428   arg1 = (floatp *)jarg1;
2429   {
2430     try {
2431       delete_floatp(arg1);
2432     } catch (std::out_of_range& e) {
2433       {
2434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2435       };
2436     } catch (std::exception& e) {
2437       {
2438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2439       };
2440     } catch (...) {
2441       {
2442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2443       };
2444     }
2445   }
2446 }
2447
2448
2449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2450   floatp *arg1 = (floatp *) 0 ;
2451   float arg2 ;
2452
2453   arg1 = (floatp *)jarg1;
2454   arg2 = (float)jarg2;
2455   {
2456     try {
2457       floatp_assign(arg1,arg2);
2458     } catch (std::out_of_range& e) {
2459       {
2460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2461       };
2462     } catch (std::exception& e) {
2463       {
2464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2465       };
2466     } catch (...) {
2467       {
2468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2469       };
2470     }
2471   }
2472 }
2473
2474
2475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2476   float jresult ;
2477   floatp *arg1 = (floatp *) 0 ;
2478   float result;
2479
2480   arg1 = (floatp *)jarg1;
2481   {
2482     try {
2483       result = (float)floatp_value(arg1);
2484     } catch (std::out_of_range& e) {
2485       {
2486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2487       };
2488     } catch (std::exception& e) {
2489       {
2490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2491       };
2492     } catch (...) {
2493       {
2494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2495       };
2496     }
2497   }
2498   jresult = result;
2499   return jresult;
2500 }
2501
2502
2503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2504   void * jresult ;
2505   floatp *arg1 = (floatp *) 0 ;
2506   float *result = 0 ;
2507
2508   arg1 = (floatp *)jarg1;
2509   {
2510     try {
2511       result = (float *)floatp_cast(arg1);
2512     } catch (std::out_of_range& e) {
2513       {
2514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2515       };
2516     } catch (std::exception& e) {
2517       {
2518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2519       };
2520     } catch (...) {
2521       {
2522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2523       };
2524     }
2525   }
2526   jresult = (void *)result;
2527   return jresult;
2528 }
2529
2530
2531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2532   void * jresult ;
2533   float *arg1 = (float *) 0 ;
2534   floatp *result = 0 ;
2535
2536   arg1 = (float *)jarg1;
2537   {
2538     try {
2539       result = (floatp *)floatp_frompointer(arg1);
2540     } catch (std::out_of_range& e) {
2541       {
2542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2543       };
2544     } catch (std::exception& e) {
2545       {
2546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2547       };
2548     } catch (...) {
2549       {
2550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2551       };
2552     }
2553   }
2554   jresult = (void *)result;
2555   return jresult;
2556 }
2557
2558
2559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2560   void * jresult ;
2561   intp *result = 0 ;
2562
2563   {
2564     try {
2565       result = (intp *)new_intp();
2566     } catch (std::out_of_range& e) {
2567       {
2568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2569       };
2570     } catch (std::exception& e) {
2571       {
2572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2573       };
2574     } catch (...) {
2575       {
2576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2577       };
2578     }
2579   }
2580   jresult = (void *)result;
2581   return jresult;
2582 }
2583
2584
2585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2586   intp *arg1 = (intp *) 0 ;
2587
2588   arg1 = (intp *)jarg1;
2589   {
2590     try {
2591       delete_intp(arg1);
2592     } catch (std::out_of_range& e) {
2593       {
2594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2595       };
2596     } catch (std::exception& e) {
2597       {
2598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2599       };
2600     } catch (...) {
2601       {
2602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2603       };
2604     }
2605   }
2606 }
2607
2608
2609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2610   intp *arg1 = (intp *) 0 ;
2611   int arg2 ;
2612
2613   arg1 = (intp *)jarg1;
2614   arg2 = (int)jarg2;
2615   {
2616     try {
2617       intp_assign(arg1,arg2);
2618     } catch (std::out_of_range& e) {
2619       {
2620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2621       };
2622     } catch (std::exception& e) {
2623       {
2624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2625       };
2626     } catch (...) {
2627       {
2628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2629       };
2630     }
2631   }
2632 }
2633
2634
2635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2636   int jresult ;
2637   intp *arg1 = (intp *) 0 ;
2638   int result;
2639
2640   arg1 = (intp *)jarg1;
2641   {
2642     try {
2643       result = (int)intp_value(arg1);
2644     } catch (std::out_of_range& e) {
2645       {
2646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2647       };
2648     } catch (std::exception& e) {
2649       {
2650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2651       };
2652     } catch (...) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2655       };
2656     }
2657   }
2658   jresult = result;
2659   return jresult;
2660 }
2661
2662
2663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2664   void * jresult ;
2665   intp *arg1 = (intp *) 0 ;
2666   int *result = 0 ;
2667
2668   arg1 = (intp *)jarg1;
2669   {
2670     try {
2671       result = (int *)intp_cast(arg1);
2672     } catch (std::out_of_range& e) {
2673       {
2674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2675       };
2676     } catch (std::exception& e) {
2677       {
2678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2679       };
2680     } catch (...) {
2681       {
2682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2683       };
2684     }
2685   }
2686   jresult = (void *)result;
2687   return jresult;
2688 }
2689
2690
2691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2692   void * jresult ;
2693   int *arg1 = (int *) 0 ;
2694   intp *result = 0 ;
2695
2696   arg1 = (int *)jarg1;
2697   {
2698     try {
2699       result = (intp *)intp_frompointer(arg1);
2700     } catch (std::out_of_range& e) {
2701       {
2702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2703       };
2704     } catch (std::exception& e) {
2705       {
2706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2707       };
2708     } catch (...) {
2709       {
2710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2711       };
2712     }
2713   }
2714   jresult = (void *)result;
2715   return jresult;
2716 }
2717
2718
2719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2720   void * jresult ;
2721   doublep *result = 0 ;
2722
2723   {
2724     try {
2725       result = (doublep *)new_doublep();
2726     } catch (std::out_of_range& e) {
2727       {
2728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2729       };
2730     } catch (std::exception& e) {
2731       {
2732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2733       };
2734     } catch (...) {
2735       {
2736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2737       };
2738     }
2739   }
2740   jresult = (void *)result;
2741   return jresult;
2742 }
2743
2744
2745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2746   doublep *arg1 = (doublep *) 0 ;
2747
2748   arg1 = (doublep *)jarg1;
2749   {
2750     try {
2751       delete_doublep(arg1);
2752     } catch (std::out_of_range& e) {
2753       {
2754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2755       };
2756     } catch (std::exception& e) {
2757       {
2758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2759       };
2760     } catch (...) {
2761       {
2762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2763       };
2764     }
2765   }
2766 }
2767
2768
2769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2770   doublep *arg1 = (doublep *) 0 ;
2771   double arg2 ;
2772
2773   arg1 = (doublep *)jarg1;
2774   arg2 = (double)jarg2;
2775   {
2776     try {
2777       doublep_assign(arg1,arg2);
2778     } catch (std::out_of_range& e) {
2779       {
2780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2781       };
2782     } catch (std::exception& e) {
2783       {
2784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2785       };
2786     } catch (...) {
2787       {
2788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2789       };
2790     }
2791   }
2792 }
2793
2794
2795 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2796   double jresult ;
2797   doublep *arg1 = (doublep *) 0 ;
2798   double result;
2799
2800   arg1 = (doublep *)jarg1;
2801   {
2802     try {
2803       result = (double)doublep_value(arg1);
2804     } catch (std::out_of_range& e) {
2805       {
2806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2807       };
2808     } catch (std::exception& e) {
2809       {
2810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2811       };
2812     } catch (...) {
2813       {
2814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2815       };
2816     }
2817   }
2818   jresult = result;
2819   return jresult;
2820 }
2821
2822
2823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2824   void * jresult ;
2825   doublep *arg1 = (doublep *) 0 ;
2826   double *result = 0 ;
2827
2828   arg1 = (doublep *)jarg1;
2829   {
2830     try {
2831       result = (double *)doublep_cast(arg1);
2832     } catch (std::out_of_range& e) {
2833       {
2834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2835       };
2836     } catch (std::exception& e) {
2837       {
2838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2839       };
2840     } catch (...) {
2841       {
2842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2843       };
2844     }
2845   }
2846   jresult = (void *)result;
2847   return jresult;
2848 }
2849
2850
2851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2852   void * jresult ;
2853   double *arg1 = (double *) 0 ;
2854   doublep *result = 0 ;
2855
2856   arg1 = (double *)jarg1;
2857   {
2858     try {
2859       result = (doublep *)doublep_frompointer(arg1);
2860     } catch (std::out_of_range& e) {
2861       {
2862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2863       };
2864     } catch (std::exception& e) {
2865       {
2866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2867       };
2868     } catch (...) {
2869       {
2870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2871       };
2872     }
2873   }
2874   jresult = (void *)result;
2875   return jresult;
2876 }
2877
2878
2879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2880   void * jresult ;
2881   uintp *result = 0 ;
2882
2883   {
2884     try {
2885       result = (uintp *)new_uintp();
2886     } catch (std::out_of_range& e) {
2887       {
2888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2889       };
2890     } catch (std::exception& e) {
2891       {
2892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2893       };
2894     } catch (...) {
2895       {
2896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2897       };
2898     }
2899   }
2900   jresult = (void *)result;
2901   return jresult;
2902 }
2903
2904
2905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2906   uintp *arg1 = (uintp *) 0 ;
2907
2908   arg1 = (uintp *)jarg1;
2909   {
2910     try {
2911       delete_uintp(arg1);
2912     } catch (std::out_of_range& e) {
2913       {
2914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2915       };
2916     } catch (std::exception& e) {
2917       {
2918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2919       };
2920     } catch (...) {
2921       {
2922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2923       };
2924     }
2925   }
2926 }
2927
2928
2929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2930   uintp *arg1 = (uintp *) 0 ;
2931   unsigned int arg2 ;
2932
2933   arg1 = (uintp *)jarg1;
2934   arg2 = (unsigned int)jarg2;
2935   {
2936     try {
2937       uintp_assign(arg1,arg2);
2938     } catch (std::out_of_range& e) {
2939       {
2940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2941       };
2942     } catch (std::exception& e) {
2943       {
2944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2945       };
2946     } catch (...) {
2947       {
2948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2949       };
2950     }
2951   }
2952 }
2953
2954
2955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2956   unsigned int jresult ;
2957   uintp *arg1 = (uintp *) 0 ;
2958   unsigned int result;
2959
2960   arg1 = (uintp *)jarg1;
2961   {
2962     try {
2963       result = (unsigned int)uintp_value(arg1);
2964     } catch (std::out_of_range& e) {
2965       {
2966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2967       };
2968     } catch (std::exception& e) {
2969       {
2970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2971       };
2972     } catch (...) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2975       };
2976     }
2977   }
2978   jresult = result;
2979   return jresult;
2980 }
2981
2982
2983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2984   void * jresult ;
2985   uintp *arg1 = (uintp *) 0 ;
2986   unsigned int *result = 0 ;
2987
2988   arg1 = (uintp *)jarg1;
2989   {
2990     try {
2991       result = (unsigned int *)uintp_cast(arg1);
2992     } catch (std::out_of_range& e) {
2993       {
2994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2995       };
2996     } catch (std::exception& e) {
2997       {
2998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2999       };
3000     } catch (...) {
3001       {
3002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3003       };
3004     }
3005   }
3006   jresult = (void *)result;
3007   return jresult;
3008 }
3009
3010
3011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3012   void * jresult ;
3013   unsigned int *arg1 = (unsigned int *) 0 ;
3014   uintp *result = 0 ;
3015
3016   arg1 = (unsigned int *)jarg1;
3017   {
3018     try {
3019       result = (uintp *)uintp_frompointer(arg1);
3020     } catch (std::out_of_range& e) {
3021       {
3022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3023       };
3024     } catch (std::exception& e) {
3025       {
3026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3027       };
3028     } catch (...) {
3029       {
3030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3031       };
3032     }
3033   }
3034   jresult = (void *)result;
3035   return jresult;
3036 }
3037
3038
3039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3040   void * jresult ;
3041   ushortp *result = 0 ;
3042
3043   {
3044     try {
3045       result = (ushortp *)new_ushortp();
3046     } catch (std::out_of_range& e) {
3047       {
3048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3049       };
3050     } catch (std::exception& e) {
3051       {
3052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3053       };
3054     } catch (...) {
3055       {
3056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3057       };
3058     }
3059   }
3060   jresult = (void *)result;
3061   return jresult;
3062 }
3063
3064
3065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3066   ushortp *arg1 = (ushortp *) 0 ;
3067
3068   arg1 = (ushortp *)jarg1;
3069   {
3070     try {
3071       delete_ushortp(arg1);
3072     } catch (std::out_of_range& e) {
3073       {
3074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3075       };
3076     } catch (std::exception& e) {
3077       {
3078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3079       };
3080     } catch (...) {
3081       {
3082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3083       };
3084     }
3085   }
3086 }
3087
3088
3089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3090   ushortp *arg1 = (ushortp *) 0 ;
3091   unsigned short arg2 ;
3092
3093   arg1 = (ushortp *)jarg1;
3094   arg2 = (unsigned short)jarg2;
3095   {
3096     try {
3097       ushortp_assign(arg1,arg2);
3098     } catch (std::out_of_range& e) {
3099       {
3100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3101       };
3102     } catch (std::exception& e) {
3103       {
3104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3105       };
3106     } catch (...) {
3107       {
3108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3109       };
3110     }
3111   }
3112 }
3113
3114
3115 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3116   unsigned short jresult ;
3117   ushortp *arg1 = (ushortp *) 0 ;
3118   unsigned short result;
3119
3120   arg1 = (ushortp *)jarg1;
3121   {
3122     try {
3123       result = (unsigned short)ushortp_value(arg1);
3124     } catch (std::out_of_range& e) {
3125       {
3126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (std::exception& e) {
3129       {
3130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3131       };
3132     } catch (...) {
3133       {
3134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3135       };
3136     }
3137   }
3138   jresult = result;
3139   return jresult;
3140 }
3141
3142
3143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3144   void * jresult ;
3145   ushortp *arg1 = (ushortp *) 0 ;
3146   unsigned short *result = 0 ;
3147
3148   arg1 = (ushortp *)jarg1;
3149   {
3150     try {
3151       result = (unsigned short *)ushortp_cast(arg1);
3152     } catch (std::out_of_range& e) {
3153       {
3154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3155       };
3156     } catch (std::exception& e) {
3157       {
3158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3159       };
3160     } catch (...) {
3161       {
3162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3163       };
3164     }
3165   }
3166   jresult = (void *)result;
3167   return jresult;
3168 }
3169
3170
3171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3172   void * jresult ;
3173   unsigned short *arg1 = (unsigned short *) 0 ;
3174   ushortp *result = 0 ;
3175
3176   arg1 = (unsigned short *)jarg1;
3177   {
3178     try {
3179       result = (ushortp *)ushortp_frompointer(arg1);
3180     } catch (std::out_of_range& e) {
3181       {
3182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3183       };
3184     } catch (std::exception& e) {
3185       {
3186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3187       };
3188     } catch (...) {
3189       {
3190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3191       };
3192     }
3193   }
3194   jresult = (void *)result;
3195   return jresult;
3196 }
3197
3198
3199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3200   unsigned int jresult ;
3201   int arg1 ;
3202   unsigned int result;
3203
3204   arg1 = (int)jarg1;
3205   {
3206     try {
3207       result = (unsigned int)int_to_uint(arg1);
3208     } catch (std::out_of_range& e) {
3209       {
3210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3211       };
3212     } catch (std::exception& e) {
3213       {
3214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3215       };
3216     } catch (...) {
3217       {
3218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3219       };
3220     }
3221   }
3222   jresult = result;
3223   return jresult;
3224 }
3225
3226
3227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3228   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3229
3230   arg1 = (Dali::RefObject *)jarg1;
3231   {
3232     try {
3233       (arg1)->Reference();
3234     } catch (std::out_of_range& e) {
3235       {
3236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3237       };
3238     } catch (std::exception& e) {
3239       {
3240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3241       };
3242     } catch (...) {
3243       {
3244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3245       };
3246     }
3247   }
3248 }
3249
3250
3251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3252   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3253
3254   arg1 = (Dali::RefObject *)jarg1;
3255   {
3256     try {
3257       (arg1)->Unreference();
3258     } catch (std::out_of_range& e) {
3259       {
3260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3261       };
3262     } catch (std::exception& e) {
3263       {
3264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3265       };
3266     } catch (...) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3269       };
3270     }
3271   }
3272 }
3273
3274
3275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3276   int jresult ;
3277   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3278   int result;
3279
3280   arg1 = (Dali::RefObject *)jarg1;
3281   {
3282     try {
3283       result = (int)(arg1)->ReferenceCount();
3284     } catch (std::out_of_range& e) {
3285       {
3286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3287       };
3288     } catch (std::exception& e) {
3289       {
3290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3291       };
3292     } catch (...) {
3293       {
3294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3295       };
3296     }
3297   }
3298   jresult = result;
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3304   void * jresult ;
3305   Dali::Any *result = 0 ;
3306
3307   {
3308     try {
3309       result = (Dali::Any *)new Dali::Any();
3310     } catch (std::out_of_range& e) {
3311       {
3312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (std::exception& e) {
3315       {
3316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3317       };
3318     } catch (...) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3321       };
3322     }
3323   }
3324   jresult = (void *)result;
3325   return jresult;
3326 }
3327
3328
3329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3330   Dali::Any *arg1 = (Dali::Any *) 0 ;
3331
3332   arg1 = (Dali::Any *)jarg1;
3333   {
3334     try {
3335       delete arg1;
3336     } catch (std::out_of_range& e) {
3337       {
3338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3339       };
3340     } catch (std::exception& e) {
3341       {
3342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3343       };
3344     } catch (...) {
3345       {
3346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3347       };
3348     }
3349   }
3350 }
3351
3352
3353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3354   char *arg1 = (char *) 0 ;
3355
3356   arg1 = (char *)jarg1;
3357   {
3358     try {
3359       Dali::Any::AssertAlways((char const *)arg1);
3360     } catch (std::out_of_range& e) {
3361       {
3362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3363       };
3364     } catch (std::exception& e) {
3365       {
3366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3367       };
3368     } catch (...) {
3369       {
3370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3371       };
3372     }
3373   }
3374 }
3375
3376
3377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3378   void * jresult ;
3379   Dali::Any *arg1 = 0 ;
3380   Dali::Any *result = 0 ;
3381
3382   arg1 = (Dali::Any *)jarg1;
3383   if (!arg1) {
3384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3385     return 0;
3386   }
3387   {
3388     try {
3389       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3390     } catch (std::out_of_range& e) {
3391       {
3392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3393       };
3394     } catch (std::exception& e) {
3395       {
3396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3401       };
3402     }
3403   }
3404   jresult = (void *)result;
3405   return jresult;
3406 }
3407
3408
3409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3410   void * jresult ;
3411   Dali::Any *arg1 = (Dali::Any *) 0 ;
3412   Dali::Any *arg2 = 0 ;
3413   Dali::Any *result = 0 ;
3414
3415   arg1 = (Dali::Any *)jarg1;
3416   arg2 = (Dali::Any *)jarg2;
3417   if (!arg2) {
3418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3419     return 0;
3420   }
3421   {
3422     try {
3423       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3424     } catch (std::out_of_range& e) {
3425       {
3426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3427       };
3428     } catch (std::exception& e) {
3429       {
3430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3431       };
3432     } catch (...) {
3433       {
3434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3435       };
3436     }
3437   }
3438   jresult = (void *)result;
3439   return jresult;
3440 }
3441
3442
3443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3444   void * jresult ;
3445   Dali::Any *arg1 = (Dali::Any *) 0 ;
3446   std::type_info *result = 0 ;
3447
3448   arg1 = (Dali::Any *)jarg1;
3449   {
3450     try {
3451       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3452     } catch (std::out_of_range& e) {
3453       {
3454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3455       };
3456     } catch (std::exception& e) {
3457       {
3458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3459       };
3460     } catch (...) {
3461       {
3462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3463       };
3464     }
3465   }
3466   jresult = (void *)result;
3467   return jresult;
3468 }
3469
3470
3471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3472   unsigned int jresult ;
3473   Dali::Any *arg1 = (Dali::Any *) 0 ;
3474   bool result;
3475
3476   arg1 = (Dali::Any *)jarg1;
3477   {
3478     try {
3479       result = (bool)((Dali::Any const *)arg1)->Empty();
3480     } catch (std::out_of_range& e) {
3481       {
3482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3483       };
3484     } catch (std::exception& e) {
3485       {
3486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3487       };
3488     } catch (...) {
3489       {
3490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3491       };
3492     }
3493   }
3494   jresult = result;
3495   return jresult;
3496 }
3497
3498
3499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3500   void * jresult ;
3501   std::type_info *arg1 = 0 ;
3502   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3503   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3504   Dali::Any::AnyContainerBase *result = 0 ;
3505
3506   arg1 = (std::type_info *)jarg1;
3507   if (!arg1) {
3508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3509     return 0;
3510   }
3511   arg2 = (Dali::Any::CloneFunc)jarg2;
3512   arg3 = (Dali::Any::DeleteFunc)jarg3;
3513   {
3514     try {
3515       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
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 void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3536   void * jresult ;
3537   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3538   std::type_info *result = 0 ;
3539
3540   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3541   {
3542     try {
3543       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
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 = (void *)result;
3559   return jresult;
3560 }
3561
3562
3563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3564   void * jresult ;
3565   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3566   ::std::type_info *result = 0 ;
3567
3568   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3569   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3570   jresult = (void *)result;
3571   return jresult;
3572 }
3573
3574
3575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3576   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3577   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3578
3579   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3580   arg2 = (Dali::Any::CloneFunc)jarg2;
3581   if (arg1) (arg1)->mCloneFunc = arg2;
3582 }
3583
3584
3585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3586   void * jresult ;
3587   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3588   Dali::Any::CloneFunc result;
3589
3590   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3591   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3592   jresult = (void *)result;
3593   return jresult;
3594 }
3595
3596
3597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3598   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3599   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3600
3601   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3602   arg2 = (Dali::Any::DeleteFunc)jarg2;
3603   if (arg1) (arg1)->mDeleteFunc = arg2;
3604 }
3605
3606
3607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3608   void * jresult ;
3609   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3610   Dali::Any::DeleteFunc result;
3611
3612   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3613   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3614   jresult = (void *)result;
3615   return jresult;
3616 }
3617
3618
3619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3620   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3621
3622   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3623   {
3624     try {
3625       delete arg1;
3626     } catch (std::out_of_range& e) {
3627       {
3628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3629       };
3630     } catch (std::exception& e) {
3631       {
3632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3633       };
3634     } catch (...) {
3635       {
3636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3637       };
3638     }
3639   }
3640 }
3641
3642
3643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3644   Dali::Any *arg1 = (Dali::Any *) 0 ;
3645   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3646
3647   arg1 = (Dali::Any *)jarg1;
3648   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3649   if (arg1) (arg1)->mContainer = arg2;
3650 }
3651
3652
3653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3654   void * jresult ;
3655   Dali::Any *arg1 = (Dali::Any *) 0 ;
3656   Dali::Any::AnyContainerBase *result = 0 ;
3657
3658   arg1 = (Dali::Any *)jarg1;
3659   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3660   jresult = (void *)result;
3661   return jresult;
3662 }
3663
3664
3665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3666   char *arg1 = (char *) 0 ;
3667   char *arg2 = (char *) 0 ;
3668
3669   arg1 = (char *)jarg1;
3670   arg2 = (char *)jarg2;
3671   {
3672     try {
3673       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3674     } catch (std::out_of_range& e) {
3675       {
3676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3677       };
3678     } catch (std::exception& e) {
3679       {
3680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3681       };
3682     } catch (...) {
3683       {
3684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3685       };
3686     }
3687   }
3688 }
3689
3690
3691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3692   void * jresult ;
3693   char *arg1 = (char *) 0 ;
3694   char *arg2 = (char *) 0 ;
3695   Dali::DaliException *result = 0 ;
3696
3697   arg1 = (char *)jarg1;
3698   arg2 = (char *)jarg2;
3699   {
3700     try {
3701       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3702     } catch (std::out_of_range& e) {
3703       {
3704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3705       };
3706     } catch (std::exception& e) {
3707       {
3708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3709       };
3710     } catch (...) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3713       };
3714     }
3715   }
3716   jresult = (void *)result;
3717   return jresult;
3718 }
3719
3720
3721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3722   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3723   char *arg2 = (char *) 0 ;
3724
3725   arg1 = (Dali::DaliException *)jarg1;
3726   arg2 = (char *)jarg2;
3727   {
3728     if (arg2) {
3729       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3730       strcpy((char *)arg1->location, (const char *)arg2);
3731     } else {
3732       arg1->location = 0;
3733     }
3734   }
3735 }
3736
3737
3738 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3739   char * jresult ;
3740   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3741   char *result = 0 ;
3742
3743   arg1 = (Dali::DaliException *)jarg1;
3744   result = (char *) ((arg1)->location);
3745   jresult = SWIG_csharp_string_callback((const char *)result);
3746   return jresult;
3747 }
3748
3749
3750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3751   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3752   char *arg2 = (char *) 0 ;
3753
3754   arg1 = (Dali::DaliException *)jarg1;
3755   arg2 = (char *)jarg2;
3756   {
3757     if (arg2) {
3758       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3759       strcpy((char *)arg1->condition, (const char *)arg2);
3760     } else {
3761       arg1->condition = 0;
3762     }
3763   }
3764 }
3765
3766
3767 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3768   char * jresult ;
3769   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3770   char *result = 0 ;
3771
3772   arg1 = (Dali::DaliException *)jarg1;
3773   result = (char *) ((arg1)->condition);
3774   jresult = SWIG_csharp_string_callback((const char *)result);
3775   return jresult;
3776 }
3777
3778
3779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3780   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3781
3782   arg1 = (Dali::DaliException *)jarg1;
3783   {
3784     try {
3785       delete arg1;
3786     } catch (std::out_of_range& e) {
3787       {
3788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3789       };
3790     } catch (std::exception& e) {
3791       {
3792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3793       };
3794     } catch (...) {
3795       {
3796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3797       };
3798     }
3799   }
3800 }
3801
3802
3803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3804   void * jresult ;
3805   Dali::Vector2 *result = 0 ;
3806
3807   {
3808     try {
3809       result = (Dali::Vector2 *)new Dali::Vector2();
3810     } catch (std::out_of_range& e) {
3811       {
3812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3813       };
3814     } catch (std::exception& e) {
3815       {
3816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3817       };
3818     } catch (...) {
3819       {
3820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3821       };
3822     }
3823   }
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3830   void * jresult ;
3831   float arg1 ;
3832   float arg2 ;
3833   Dali::Vector2 *result = 0 ;
3834
3835   arg1 = (float)jarg1;
3836   arg2 = (float)jarg2;
3837   {
3838     try {
3839       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3840     } catch (std::out_of_range& e) {
3841       {
3842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3843       };
3844     } catch (std::exception& e) {
3845       {
3846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3847       };
3848     } catch (...) {
3849       {
3850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3851       };
3852     }
3853   }
3854   jresult = (void *)result;
3855   return jresult;
3856 }
3857
3858
3859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3860   void * jresult ;
3861   float *arg1 = (float *) 0 ;
3862   Dali::Vector2 *result = 0 ;
3863
3864   arg1 = jarg1;
3865   {
3866     try {
3867       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3868     } catch (std::out_of_range& e) {
3869       {
3870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3871       };
3872     } catch (std::exception& e) {
3873       {
3874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3875       };
3876     } catch (...) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3879       };
3880     }
3881   }
3882   jresult = (void *)result;
3883
3884
3885   return jresult;
3886 }
3887
3888
3889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3890   void * jresult ;
3891   Dali::Vector3 *arg1 = 0 ;
3892   Dali::Vector2 *result = 0 ;
3893
3894   arg1 = (Dali::Vector3 *)jarg1;
3895   if (!arg1) {
3896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3897     return 0;
3898   }
3899   {
3900     try {
3901       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3902     } catch (std::out_of_range& e) {
3903       {
3904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3905       };
3906     } catch (std::exception& e) {
3907       {
3908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3909       };
3910     } catch (...) {
3911       {
3912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3913       };
3914     }
3915   }
3916   jresult = (void *)result;
3917   return jresult;
3918 }
3919
3920
3921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3922   void * jresult ;
3923   Dali::Vector4 *arg1 = 0 ;
3924   Dali::Vector2 *result = 0 ;
3925
3926   arg1 = (Dali::Vector4 *)jarg1;
3927   if (!arg1) {
3928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3929     return 0;
3930   }
3931   {
3932     try {
3933       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3934     } catch (std::out_of_range& e) {
3935       {
3936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3937       };
3938     } catch (std::exception& e) {
3939       {
3940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3941       };
3942     } catch (...) {
3943       {
3944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3945       };
3946     }
3947   }
3948   jresult = (void *)result;
3949   return jresult;
3950 }
3951
3952
3953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3954   void * jresult ;
3955   Dali::Vector2 *result = 0 ;
3956
3957   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3958   jresult = (void *)result;
3959   return jresult;
3960 }
3961
3962
3963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3964   void * jresult ;
3965   Dali::Vector2 *result = 0 ;
3966
3967   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3968   jresult = (void *)result;
3969   return jresult;
3970 }
3971
3972
3973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3974   void * jresult ;
3975   Dali::Vector2 *result = 0 ;
3976
3977   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3978   jresult = (void *)result;
3979   return jresult;
3980 }
3981
3982
3983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3984   void * jresult ;
3985   Dali::Vector2 *result = 0 ;
3986
3987   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3988   jresult = (void *)result;
3989   return jresult;
3990 }
3991
3992
3993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3994   void * jresult ;
3995   Dali::Vector2 *result = 0 ;
3996
3997   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4004   void * jresult ;
4005   Dali::Vector2 *result = 0 ;
4006
4007   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4008   jresult = (void *)result;
4009   return jresult;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4014   void * jresult ;
4015   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4016   float *arg2 = (float *) 0 ;
4017   Dali::Vector2 *result = 0 ;
4018
4019   arg1 = (Dali::Vector2 *)jarg1;
4020   arg2 = jarg2;
4021   {
4022     try {
4023       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4024     } catch (std::out_of_range& e) {
4025       {
4026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4027       };
4028     } catch (std::exception& e) {
4029       {
4030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4031       };
4032     } catch (...) {
4033       {
4034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4035       };
4036     }
4037   }
4038   jresult = (void *)result;
4039
4040
4041   return jresult;
4042 }
4043
4044
4045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4046   void * jresult ;
4047   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4048   Dali::Vector3 *arg2 = 0 ;
4049   Dali::Vector2 *result = 0 ;
4050
4051   arg1 = (Dali::Vector2 *)jarg1;
4052   arg2 = (Dali::Vector3 *)jarg2;
4053   if (!arg2) {
4054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4055     return 0;
4056   }
4057   {
4058     try {
4059       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4060     } catch (std::out_of_range& e) {
4061       {
4062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4063       };
4064     } catch (std::exception& e) {
4065       {
4066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4067       };
4068     } catch (...) {
4069       {
4070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4071       };
4072     }
4073   }
4074   jresult = (void *)result;
4075   return jresult;
4076 }
4077
4078
4079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4080   void * jresult ;
4081   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4082   Dali::Vector4 *arg2 = 0 ;
4083   Dali::Vector2 *result = 0 ;
4084
4085   arg1 = (Dali::Vector2 *)jarg1;
4086   arg2 = (Dali::Vector4 *)jarg2;
4087   if (!arg2) {
4088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4089     return 0;
4090   }
4091   {
4092     try {
4093       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4094     } catch (std::out_of_range& e) {
4095       {
4096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4097       };
4098     } catch (std::exception& e) {
4099       {
4100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4101       };
4102     } catch (...) {
4103       {
4104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4105       };
4106     }
4107   }
4108   jresult = (void *)result;
4109   return jresult;
4110 }
4111
4112
4113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4114   void * jresult ;
4115   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4116   Dali::Vector2 *arg2 = 0 ;
4117   Dali::Vector2 result;
4118
4119   arg1 = (Dali::Vector2 *)jarg1;
4120   arg2 = (Dali::Vector2 *)jarg2;
4121   if (!arg2) {
4122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4123     return 0;
4124   }
4125   {
4126     try {
4127       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4128     } catch (std::out_of_range& e) {
4129       {
4130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4131       };
4132     } catch (std::exception& e) {
4133       {
4134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4135       };
4136     } catch (...) {
4137       {
4138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4139       };
4140     }
4141   }
4142   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4143   return jresult;
4144 }
4145
4146
4147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4148   void * jresult ;
4149   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4150   Dali::Vector2 *arg2 = 0 ;
4151   Dali::Vector2 *result = 0 ;
4152
4153   arg1 = (Dali::Vector2 *)jarg1;
4154   arg2 = (Dali::Vector2 *)jarg2;
4155   if (!arg2) {
4156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4157     return 0;
4158   }
4159   {
4160     try {
4161       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4162     } catch (std::out_of_range& e) {
4163       {
4164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4165       };
4166     } catch (std::exception& e) {
4167       {
4168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4169       };
4170     } catch (...) {
4171       {
4172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4173       };
4174     }
4175   }
4176   jresult = (void *)result;
4177   return jresult;
4178 }
4179
4180
4181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4182   void * jresult ;
4183   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4184   Dali::Vector2 *arg2 = 0 ;
4185   Dali::Vector2 result;
4186
4187   arg1 = (Dali::Vector2 *)jarg1;
4188   arg2 = (Dali::Vector2 *)jarg2;
4189   if (!arg2) {
4190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4191     return 0;
4192   }
4193   {
4194     try {
4195       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4196     } catch (std::out_of_range& e) {
4197       {
4198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4199       };
4200     } catch (std::exception& e) {
4201       {
4202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4203       };
4204     } catch (...) {
4205       {
4206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4207       };
4208     }
4209   }
4210   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4211   return jresult;
4212 }
4213
4214
4215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4216   void * jresult ;
4217   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4218   Dali::Vector2 *arg2 = 0 ;
4219   Dali::Vector2 *result = 0 ;
4220
4221   arg1 = (Dali::Vector2 *)jarg1;
4222   arg2 = (Dali::Vector2 *)jarg2;
4223   if (!arg2) {
4224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4225     return 0;
4226   }
4227   {
4228     try {
4229       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4230     } catch (std::out_of_range& e) {
4231       {
4232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (std::exception& e) {
4235       {
4236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4237       };
4238     } catch (...) {
4239       {
4240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4241       };
4242     }
4243   }
4244   jresult = (void *)result;
4245   return jresult;
4246 }
4247
4248
4249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4250   void * jresult ;
4251   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4252   Dali::Vector2 *arg2 = 0 ;
4253   Dali::Vector2 result;
4254
4255   arg1 = (Dali::Vector2 *)jarg1;
4256   arg2 = (Dali::Vector2 *)jarg2;
4257   if (!arg2) {
4258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4259     return 0;
4260   }
4261   {
4262     try {
4263       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4264     } catch (std::out_of_range& e) {
4265       {
4266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (std::exception& e) {
4269       {
4270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4271       };
4272     } catch (...) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4275       };
4276     }
4277   }
4278   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4279   return jresult;
4280 }
4281
4282
4283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4284   void * jresult ;
4285   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4286   float arg2 ;
4287   Dali::Vector2 result;
4288
4289   arg1 = (Dali::Vector2 *)jarg1;
4290   arg2 = (float)jarg2;
4291   {
4292     try {
4293       result = ((Dali::Vector2 const *)arg1)->operator *(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 = new Dali::Vector2((const Dali::Vector2 &)result);
4309   return jresult;
4310 }
4311
4312
4313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__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 = 0 ;
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 *) &(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 = (void *)result;
4343   return jresult;
4344 }
4345
4346
4347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4348   void * jresult ;
4349   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4350   float arg2 ;
4351   Dali::Vector2 *result = 0 ;
4352
4353   arg1 = (Dali::Vector2 *)jarg1;
4354   arg2 = (float)jarg2;
4355   {
4356     try {
4357       result = (Dali::Vector2 *) &(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 = (void *)result;
4373   return jresult;
4374 }
4375
4376
4377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__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;
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 const *)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 = new Dali::Vector2((const Dali::Vector2 &)result);
4407   return jresult;
4408 }
4409
4410
4411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4412   void * jresult ;
4413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4414   float arg2 ;
4415   Dali::Vector2 result;
4416
4417   arg1 = (Dali::Vector2 *)jarg1;
4418   arg2 = (float)jarg2;
4419   {
4420     try {
4421       result = ((Dali::Vector2 const *)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 = new Dali::Vector2((const Dali::Vector2 &)result);
4437   return jresult;
4438 }
4439
4440
4441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__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 = 0 ;
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 *) &(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 = (void *)result;
4471   return jresult;
4472 }
4473
4474
4475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4476   void * jresult ;
4477   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4478   float arg2 ;
4479   Dali::Vector2 *result = 0 ;
4480
4481   arg1 = (Dali::Vector2 *)jarg1;
4482   arg2 = (float)jarg2;
4483   {
4484     try {
4485       result = (Dali::Vector2 *) &(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 = (void *)result;
4501   return jresult;
4502 }
4503
4504
4505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4506   void * jresult ;
4507   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4508   Dali::Vector2 result;
4509
4510   arg1 = (Dali::Vector2 *)jarg1;
4511   {
4512     try {
4513       result = ((Dali::Vector2 const *)arg1)->operator -();
4514     } catch (std::out_of_range& e) {
4515       {
4516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4517       };
4518     } catch (std::exception& e) {
4519       {
4520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4521       };
4522     } catch (...) {
4523       {
4524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4525       };
4526     }
4527   }
4528   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4534   unsigned int jresult ;
4535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4536   Dali::Vector2 *arg2 = 0 ;
4537   bool result;
4538
4539   arg1 = (Dali::Vector2 *)jarg1;
4540   arg2 = (Dali::Vector2 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4548     } catch (std::out_of_range& e) {
4549       {
4550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (std::exception& e) {
4553       {
4554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4555       };
4556     } catch (...) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4559       };
4560     }
4561   }
4562   jresult = result;
4563   return jresult;
4564 }
4565
4566
4567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4568   unsigned int jresult ;
4569   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4570   Dali::Vector2 *arg2 = 0 ;
4571   bool result;
4572
4573   arg1 = (Dali::Vector2 *)jarg1;
4574   arg2 = (Dali::Vector2 *)jarg2;
4575   if (!arg2) {
4576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4577     return 0;
4578   }
4579   {
4580     try {
4581       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4582     } catch (std::out_of_range& e) {
4583       {
4584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4585       };
4586     } catch (std::exception& e) {
4587       {
4588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4589       };
4590     } catch (...) {
4591       {
4592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4593       };
4594     }
4595   }
4596   jresult = result;
4597   return jresult;
4598 }
4599
4600
4601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4602   float jresult ;
4603   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4604   unsigned int arg2 ;
4605   float *result = 0 ;
4606
4607   arg1 = (Dali::Vector2 *)jarg1;
4608   arg2 = (unsigned int)jarg2;
4609   {
4610     try {
4611       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](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 float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4632   float jresult ;
4633   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4634   float result;
4635
4636   arg1 = (Dali::Vector2 *)jarg1;
4637   {
4638     try {
4639       result = (float)((Dali::Vector2 const *)arg1)->Length();
4640     } catch (std::out_of_range& e) {
4641       {
4642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4643       };
4644     } catch (std::exception& e) {
4645       {
4646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4647       };
4648     } catch (...) {
4649       {
4650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4651       };
4652     }
4653   }
4654   jresult = result;
4655   return jresult;
4656 }
4657
4658
4659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4660   float jresult ;
4661   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4662   float result;
4663
4664   arg1 = (Dali::Vector2 *)jarg1;
4665   {
4666     try {
4667       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4668     } catch (std::out_of_range& e) {
4669       {
4670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4671       };
4672     } catch (std::exception& e) {
4673       {
4674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4675       };
4676     } catch (...) {
4677       {
4678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4679       };
4680     }
4681   }
4682   jresult = result;
4683   return jresult;
4684 }
4685
4686
4687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4688   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4689
4690   arg1 = (Dali::Vector2 *)jarg1;
4691   {
4692     try {
4693       (arg1)->Normalize();
4694     } catch (std::out_of_range& e) {
4695       {
4696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4697       };
4698     } catch (std::exception& e) {
4699       {
4700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4701       };
4702     } catch (...) {
4703       {
4704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4705       };
4706     }
4707   }
4708 }
4709
4710
4711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4712   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4713   Dali::Vector2 *arg2 = 0 ;
4714   Dali::Vector2 *arg3 = 0 ;
4715
4716   arg1 = (Dali::Vector2 *)jarg1;
4717   arg2 = (Dali::Vector2 *)jarg2;
4718   if (!arg2) {
4719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4720     return ;
4721   }
4722   arg3 = (Dali::Vector2 *)jarg3;
4723   if (!arg3) {
4724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4725     return ;
4726   }
4727   {
4728     try {
4729       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4730     } catch (std::out_of_range& e) {
4731       {
4732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4733       };
4734     } catch (std::exception& e) {
4735       {
4736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4737       };
4738     } catch (...) {
4739       {
4740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4741       };
4742     }
4743   }
4744 }
4745
4746
4747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4748   void * jresult ;
4749   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4750   float *result = 0 ;
4751
4752   arg1 = (Dali::Vector2 *)jarg1;
4753   {
4754     try {
4755       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4756     } catch (std::out_of_range& e) {
4757       {
4758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4759       };
4760     } catch (std::exception& e) {
4761       {
4762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4763       };
4764     } catch (...) {
4765       {
4766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4767       };
4768     }
4769   }
4770   jresult = (void *)result;
4771   return jresult;
4772 }
4773
4774
4775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4777   float arg2 ;
4778
4779   arg1 = (Dali::Vector2 *)jarg1;
4780   arg2 = (float)jarg2;
4781   if (arg1) (arg1)->x = arg2;
4782 }
4783
4784
4785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4786   float jresult ;
4787   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4788   float result;
4789
4790   arg1 = (Dali::Vector2 *)jarg1;
4791   result = (float) ((arg1)->x);
4792   jresult = result;
4793   return jresult;
4794 }
4795
4796
4797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4798   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4799   float arg2 ;
4800
4801   arg1 = (Dali::Vector2 *)jarg1;
4802   arg2 = (float)jarg2;
4803   if (arg1) (arg1)->width = arg2;
4804 }
4805
4806
4807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4808   float jresult ;
4809   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4810   float result;
4811
4812   arg1 = (Dali::Vector2 *)jarg1;
4813   result = (float) ((arg1)->width);
4814   jresult = result;
4815   return jresult;
4816 }
4817
4818
4819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4820   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4821   float arg2 ;
4822
4823   arg1 = (Dali::Vector2 *)jarg1;
4824   arg2 = (float)jarg2;
4825   if (arg1) (arg1)->y = arg2;
4826 }
4827
4828
4829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4830   float jresult ;
4831   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4832   float result;
4833
4834   arg1 = (Dali::Vector2 *)jarg1;
4835   result = (float) ((arg1)->y);
4836   jresult = result;
4837   return jresult;
4838 }
4839
4840
4841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4842   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4843   float arg2 ;
4844
4845   arg1 = (Dali::Vector2 *)jarg1;
4846   arg2 = (float)jarg2;
4847   if (arg1) (arg1)->height = arg2;
4848 }
4849
4850
4851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4852   float jresult ;
4853   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4854   float result;
4855
4856   arg1 = (Dali::Vector2 *)jarg1;
4857   result = (float) ((arg1)->height);
4858   jresult = result;
4859   return jresult;
4860 }
4861
4862
4863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4864   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4865
4866   arg1 = (Dali::Vector2 *)jarg1;
4867   {
4868     try {
4869       delete arg1;
4870     } catch (std::out_of_range& e) {
4871       {
4872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4873       };
4874     } catch (std::exception& e) {
4875       {
4876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4877       };
4878     } catch (...) {
4879       {
4880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4881       };
4882     }
4883   }
4884 }
4885
4886
4887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4888   void * jresult ;
4889   Dali::Vector2 *arg1 = 0 ;
4890   Dali::Vector2 *arg2 = 0 ;
4891   Dali::Vector2 result;
4892
4893   arg1 = (Dali::Vector2 *)jarg1;
4894   if (!arg1) {
4895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4896     return 0;
4897   }
4898   arg2 = (Dali::Vector2 *)jarg2;
4899   if (!arg2) {
4900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4901     return 0;
4902   }
4903   {
4904     try {
4905       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4906     } catch (std::out_of_range& e) {
4907       {
4908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4909       };
4910     } catch (std::exception& e) {
4911       {
4912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4913       };
4914     } catch (...) {
4915       {
4916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4917       };
4918     }
4919   }
4920   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4921   return jresult;
4922 }
4923
4924
4925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4926   void * jresult ;
4927   Dali::Vector2 *arg1 = 0 ;
4928   Dali::Vector2 *arg2 = 0 ;
4929   Dali::Vector2 result;
4930
4931   arg1 = (Dali::Vector2 *)jarg1;
4932   if (!arg1) {
4933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4934     return 0;
4935   }
4936   arg2 = (Dali::Vector2 *)jarg2;
4937   if (!arg2) {
4938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4939     return 0;
4940   }
4941   {
4942     try {
4943       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4944     } catch (std::out_of_range& e) {
4945       {
4946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4947       };
4948     } catch (std::exception& e) {
4949       {
4950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4951       };
4952     } catch (...) {
4953       {
4954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4955       };
4956     }
4957   }
4958   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4959   return jresult;
4960 }
4961
4962
4963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4964   void * jresult ;
4965   Dali::Vector2 *arg1 = 0 ;
4966   float *arg2 = 0 ;
4967   float *arg3 = 0 ;
4968   float temp2 ;
4969   float temp3 ;
4970   Dali::Vector2 result;
4971
4972   arg1 = (Dali::Vector2 *)jarg1;
4973   if (!arg1) {
4974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4975     return 0;
4976   }
4977   temp2 = (float)jarg2;
4978   arg2 = &temp2;
4979   temp3 = (float)jarg3;
4980   arg3 = &temp3;
4981   {
4982     try {
4983       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4984     } catch (std::out_of_range& e) {
4985       {
4986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4987       };
4988     } catch (std::exception& e) {
4989       {
4990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4991       };
4992     } catch (...) {
4993       {
4994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4995       };
4996     }
4997   }
4998   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4999   return jresult;
5000 }
5001
5002
5003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5004   void * jresult ;
5005   Dali::Vector3 *result = 0 ;
5006
5007   {
5008     try {
5009       result = (Dali::Vector3 *)new Dali::Vector3();
5010     } catch (std::out_of_range& e) {
5011       {
5012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5013       };
5014     } catch (std::exception& e) {
5015       {
5016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5017       };
5018     } catch (...) {
5019       {
5020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5021       };
5022     }
5023   }
5024   jresult = (void *)result;
5025   return jresult;
5026 }
5027
5028
5029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5030   void * jresult ;
5031   float arg1 ;
5032   float arg2 ;
5033   float arg3 ;
5034   Dali::Vector3 *result = 0 ;
5035
5036   arg1 = (float)jarg1;
5037   arg2 = (float)jarg2;
5038   arg3 = (float)jarg3;
5039   {
5040     try {
5041       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5042     } catch (std::out_of_range& e) {
5043       {
5044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5045       };
5046     } catch (std::exception& e) {
5047       {
5048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5049       };
5050     } catch (...) {
5051       {
5052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5053       };
5054     }
5055   }
5056   jresult = (void *)result;
5057   return jresult;
5058 }
5059
5060
5061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5062   void * jresult ;
5063   float *arg1 = (float *) 0 ;
5064   Dali::Vector3 *result = 0 ;
5065
5066   arg1 = jarg1;
5067   {
5068     try {
5069       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5070     } catch (std::out_of_range& e) {
5071       {
5072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (std::exception& e) {
5075       {
5076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (...) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5081       };
5082     }
5083   }
5084   jresult = (void *)result;
5085
5086
5087   return jresult;
5088 }
5089
5090
5091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5092   void * jresult ;
5093   Dali::Vector2 *arg1 = 0 ;
5094   Dali::Vector3 *result = 0 ;
5095
5096   arg1 = (Dali::Vector2 *)jarg1;
5097   if (!arg1) {
5098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5099     return 0;
5100   }
5101   {
5102     try {
5103       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5104     } catch (std::out_of_range& e) {
5105       {
5106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5107       };
5108     } catch (std::exception& e) {
5109       {
5110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5111       };
5112     } catch (...) {
5113       {
5114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5115       };
5116     }
5117   }
5118   jresult = (void *)result;
5119   return jresult;
5120 }
5121
5122
5123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5124   void * jresult ;
5125   Dali::Vector4 *arg1 = 0 ;
5126   Dali::Vector3 *result = 0 ;
5127
5128   arg1 = (Dali::Vector4 *)jarg1;
5129   if (!arg1) {
5130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5131     return 0;
5132   }
5133   {
5134     try {
5135       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5136     } catch (std::out_of_range& e) {
5137       {
5138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5139       };
5140     } catch (std::exception& e) {
5141       {
5142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5143       };
5144     } catch (...) {
5145       {
5146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5147       };
5148     }
5149   }
5150   jresult = (void *)result;
5151   return jresult;
5152 }
5153
5154
5155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5156   void * jresult ;
5157   Dali::Vector3 *result = 0 ;
5158
5159   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5160   jresult = (void *)result;
5161   return jresult;
5162 }
5163
5164
5165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5166   void * jresult ;
5167   Dali::Vector3 *result = 0 ;
5168
5169   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5170   jresult = (void *)result;
5171   return jresult;
5172 }
5173
5174
5175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5176   void * jresult ;
5177   Dali::Vector3 *result = 0 ;
5178
5179   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5180   jresult = (void *)result;
5181   return jresult;
5182 }
5183
5184
5185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5186   void * jresult ;
5187   Dali::Vector3 *result = 0 ;
5188
5189   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5190   jresult = (void *)result;
5191   return jresult;
5192 }
5193
5194
5195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5196   void * jresult ;
5197   Dali::Vector3 *result = 0 ;
5198
5199   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5200   jresult = (void *)result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5206   void * jresult ;
5207   Dali::Vector3 *result = 0 ;
5208
5209   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5210   jresult = (void *)result;
5211   return jresult;
5212 }
5213
5214
5215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5216   void * jresult ;
5217   Dali::Vector3 *result = 0 ;
5218
5219   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5220   jresult = (void *)result;
5221   return jresult;
5222 }
5223
5224
5225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5226   void * jresult ;
5227   Dali::Vector3 *result = 0 ;
5228
5229   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5230   jresult = (void *)result;
5231   return jresult;
5232 }
5233
5234
5235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5236   void * jresult ;
5237   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5238   float *arg2 = (float *) 0 ;
5239   Dali::Vector3 *result = 0 ;
5240
5241   arg1 = (Dali::Vector3 *)jarg1;
5242   arg2 = jarg2;
5243   {
5244     try {
5245       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5246     } catch (std::out_of_range& e) {
5247       {
5248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5249       };
5250     } catch (std::exception& e) {
5251       {
5252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5253       };
5254     } catch (...) {
5255       {
5256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5257       };
5258     }
5259   }
5260   jresult = (void *)result;
5261
5262
5263   return jresult;
5264 }
5265
5266
5267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5268   void * jresult ;
5269   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5270   Dali::Vector2 *arg2 = 0 ;
5271   Dali::Vector3 *result = 0 ;
5272
5273   arg1 = (Dali::Vector3 *)jarg1;
5274   arg2 = (Dali::Vector2 *)jarg2;
5275   if (!arg2) {
5276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5277     return 0;
5278   }
5279   {
5280     try {
5281       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5282     } catch (std::out_of_range& e) {
5283       {
5284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5285       };
5286     } catch (std::exception& e) {
5287       {
5288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5289       };
5290     } catch (...) {
5291       {
5292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5293       };
5294     }
5295   }
5296   jresult = (void *)result;
5297   return jresult;
5298 }
5299
5300
5301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5302   void * jresult ;
5303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5304   Dali::Vector4 *arg2 = 0 ;
5305   Dali::Vector3 *result = 0 ;
5306
5307   arg1 = (Dali::Vector3 *)jarg1;
5308   arg2 = (Dali::Vector4 *)jarg2;
5309   if (!arg2) {
5310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5311     return 0;
5312   }
5313   {
5314     try {
5315       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5316     } catch (std::out_of_range& e) {
5317       {
5318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5319       };
5320     } catch (std::exception& e) {
5321       {
5322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5323       };
5324     } catch (...) {
5325       {
5326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5327       };
5328     }
5329   }
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5336   void * jresult ;
5337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5338   Dali::Vector3 *arg2 = 0 ;
5339   Dali::Vector3 result;
5340
5341   arg1 = (Dali::Vector3 *)jarg1;
5342   arg2 = (Dali::Vector3 *)jarg2;
5343   if (!arg2) {
5344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5345     return 0;
5346   }
5347   {
5348     try {
5349       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5350     } catch (std::out_of_range& e) {
5351       {
5352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5353       };
5354     } catch (std::exception& e) {
5355       {
5356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5357       };
5358     } catch (...) {
5359       {
5360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5361       };
5362     }
5363   }
5364   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5365   return jresult;
5366 }
5367
5368
5369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5370   void * jresult ;
5371   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5372   Dali::Vector3 *arg2 = 0 ;
5373   Dali::Vector3 *result = 0 ;
5374
5375   arg1 = (Dali::Vector3 *)jarg1;
5376   arg2 = (Dali::Vector3 *)jarg2;
5377   if (!arg2) {
5378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5379     return 0;
5380   }
5381   {
5382     try {
5383       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5384     } catch (std::out_of_range& e) {
5385       {
5386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5387       };
5388     } catch (std::exception& e) {
5389       {
5390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5391       };
5392     } catch (...) {
5393       {
5394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5395       };
5396     }
5397   }
5398   jresult = (void *)result;
5399   return jresult;
5400 }
5401
5402
5403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5404   void * jresult ;
5405   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5406   Dali::Vector3 *arg2 = 0 ;
5407   Dali::Vector3 result;
5408
5409   arg1 = (Dali::Vector3 *)jarg1;
5410   arg2 = (Dali::Vector3 *)jarg2;
5411   if (!arg2) {
5412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5413     return 0;
5414   }
5415   {
5416     try {
5417       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5418     } catch (std::out_of_range& e) {
5419       {
5420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5421       };
5422     } catch (std::exception& e) {
5423       {
5424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5425       };
5426     } catch (...) {
5427       {
5428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5429       };
5430     }
5431   }
5432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5433   return jresult;
5434 }
5435
5436
5437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5438   void * jresult ;
5439   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5440   Dali::Vector3 *arg2 = 0 ;
5441   Dali::Vector3 *result = 0 ;
5442
5443   arg1 = (Dali::Vector3 *)jarg1;
5444   arg2 = (Dali::Vector3 *)jarg2;
5445   if (!arg2) {
5446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5447     return 0;
5448   }
5449   {
5450     try {
5451       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5452     } catch (std::out_of_range& e) {
5453       {
5454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5455       };
5456     } catch (std::exception& e) {
5457       {
5458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5459       };
5460     } catch (...) {
5461       {
5462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5463       };
5464     }
5465   }
5466   jresult = (void *)result;
5467   return jresult;
5468 }
5469
5470
5471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5472   void * jresult ;
5473   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5474   Dali::Vector3 *arg2 = 0 ;
5475   Dali::Vector3 result;
5476
5477   arg1 = (Dali::Vector3 *)jarg1;
5478   arg2 = (Dali::Vector3 *)jarg2;
5479   if (!arg2) {
5480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5481     return 0;
5482   }
5483   {
5484     try {
5485       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5486     } catch (std::out_of_range& e) {
5487       {
5488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5489       };
5490     } catch (std::exception& e) {
5491       {
5492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5493       };
5494     } catch (...) {
5495       {
5496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5497       };
5498     }
5499   }
5500   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5501   return jresult;
5502 }
5503
5504
5505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5506   void * jresult ;
5507   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5508   float arg2 ;
5509   Dali::Vector3 result;
5510
5511   arg1 = (Dali::Vector3 *)jarg1;
5512   arg2 = (float)jarg2;
5513   {
5514     try {
5515       result = ((Dali::Vector3 const *)arg1)->operator *(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 = new Dali::Vector3((const Dali::Vector3 &)result);
5531   return jresult;
5532 }
5533
5534
5535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__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 = 0 ;
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 *) &(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 = (void *)result;
5565   return jresult;
5566 }
5567
5568
5569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5570   void * jresult ;
5571   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5572   float arg2 ;
5573   Dali::Vector3 *result = 0 ;
5574
5575   arg1 = (Dali::Vector3 *)jarg1;
5576   arg2 = (float)jarg2;
5577   {
5578     try {
5579       result = (Dali::Vector3 *) &(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 = (void *)result;
5595   return jresult;
5596 }
5597
5598
5599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5600   void * jresult ;
5601   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5602   Dali::Quaternion *arg2 = 0 ;
5603   Dali::Vector3 *result = 0 ;
5604
5605   arg1 = (Dali::Vector3 *)jarg1;
5606   arg2 = (Dali::Quaternion *)jarg2;
5607   if (!arg2) {
5608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5609     return 0;
5610   }
5611   {
5612     try {
5613       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion 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_Divide__SWIG_0(void * jarg1, void * jarg2) {
5634   void * jresult ;
5635   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5636   Dali::Vector3 *arg2 = 0 ;
5637   Dali::Vector3 result;
5638
5639   arg1 = (Dali::Vector3 *)jarg1;
5640   arg2 = (Dali::Vector3 *)jarg2;
5641   if (!arg2) {
5642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5643     return 0;
5644   }
5645   {
5646     try {
5647       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5648     } catch (std::out_of_range& e) {
5649       {
5650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5651       };
5652     } catch (std::exception& e) {
5653       {
5654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5655       };
5656     } catch (...) {
5657       {
5658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5659       };
5660     }
5661   }
5662   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5663   return jresult;
5664 }
5665
5666
5667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5668   void * jresult ;
5669   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5670   float arg2 ;
5671   Dali::Vector3 result;
5672
5673   arg1 = (Dali::Vector3 *)jarg1;
5674   arg2 = (float)jarg2;
5675   {
5676     try {
5677       result = ((Dali::Vector3 const *)arg1)->operator /(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 = new Dali::Vector3((const Dali::Vector3 &)result);
5693   return jresult;
5694 }
5695
5696
5697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__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 = 0 ;
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 *) &(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 = (void *)result;
5727   return jresult;
5728 }
5729
5730
5731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5732   void * jresult ;
5733   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5734   float arg2 ;
5735   Dali::Vector3 *result = 0 ;
5736
5737   arg1 = (Dali::Vector3 *)jarg1;
5738   arg2 = (float)jarg2;
5739   {
5740     try {
5741       result = (Dali::Vector3 *) &(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 = (void *)result;
5757   return jresult;
5758 }
5759
5760
5761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5762   void * jresult ;
5763   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5764   Dali::Vector3 result;
5765
5766   arg1 = (Dali::Vector3 *)jarg1;
5767   {
5768     try {
5769       result = ((Dali::Vector3 const *)arg1)->operator -();
5770     } catch (std::out_of_range& e) {
5771       {
5772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5773       };
5774     } catch (std::exception& e) {
5775       {
5776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5777       };
5778     } catch (...) {
5779       {
5780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5781       };
5782     }
5783   }
5784   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5785   return jresult;
5786 }
5787
5788
5789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5790   unsigned int jresult ;
5791   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5792   Dali::Vector3 *arg2 = 0 ;
5793   bool result;
5794
5795   arg1 = (Dali::Vector3 *)jarg1;
5796   arg2 = (Dali::Vector3 *)jarg2;
5797   if (!arg2) {
5798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5799     return 0;
5800   }
5801   {
5802     try {
5803       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5804     } catch (std::out_of_range& e) {
5805       {
5806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5807       };
5808     } catch (std::exception& e) {
5809       {
5810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5811       };
5812     } catch (...) {
5813       {
5814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5815       };
5816     }
5817   }
5818   jresult = result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5824   unsigned int jresult ;
5825   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5826   Dali::Vector3 *arg2 = 0 ;
5827   bool result;
5828
5829   arg1 = (Dali::Vector3 *)jarg1;
5830   arg2 = (Dali::Vector3 *)jarg2;
5831   if (!arg2) {
5832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5833     return 0;
5834   }
5835   {
5836     try {
5837       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5838     } catch (std::out_of_range& e) {
5839       {
5840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5841       };
5842     } catch (std::exception& e) {
5843       {
5844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5845       };
5846     } catch (...) {
5847       {
5848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5849       };
5850     }
5851   }
5852   jresult = result;
5853   return jresult;
5854 }
5855
5856
5857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5858   float jresult ;
5859   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5860   unsigned int arg2 ;
5861   float *result = 0 ;
5862
5863   arg1 = (Dali::Vector3 *)jarg1;
5864   arg2 = (unsigned int)jarg2;
5865   {
5866     try {
5867       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](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 float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5888   float jresult ;
5889   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5890   Dali::Vector3 *arg2 = 0 ;
5891   float 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 = (float)((Dali::Vector3 const *)arg1)->Dot((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 void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5922   void * jresult ;
5923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5924   Dali::Vector3 *arg2 = 0 ;
5925   Dali::Vector3 result;
5926
5927   arg1 = (Dali::Vector3 *)jarg1;
5928   arg2 = (Dali::Vector3 *)jarg2;
5929   if (!arg2) {
5930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5931     return 0;
5932   }
5933   {
5934     try {
5935       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5936     } catch (std::out_of_range& e) {
5937       {
5938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5939       };
5940     } catch (std::exception& e) {
5941       {
5942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5943       };
5944     } catch (...) {
5945       {
5946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5947       };
5948     }
5949   }
5950   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5951   return jresult;
5952 }
5953
5954
5955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5956   float jresult ;
5957   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5958   float result;
5959
5960   arg1 = (Dali::Vector3 *)jarg1;
5961   {
5962     try {
5963       result = (float)((Dali::Vector3 const *)arg1)->Length();
5964     } catch (std::out_of_range& e) {
5965       {
5966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5967       };
5968     } catch (std::exception& e) {
5969       {
5970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5971       };
5972     } catch (...) {
5973       {
5974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5975       };
5976     }
5977   }
5978   jresult = result;
5979   return jresult;
5980 }
5981
5982
5983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5984   float jresult ;
5985   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5986   float result;
5987
5988   arg1 = (Dali::Vector3 *)jarg1;
5989   {
5990     try {
5991       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5992     } catch (std::out_of_range& e) {
5993       {
5994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5995       };
5996     } catch (std::exception& e) {
5997       {
5998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5999       };
6000     } catch (...) {
6001       {
6002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6003       };
6004     }
6005   }
6006   jresult = result;
6007   return jresult;
6008 }
6009
6010
6011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6012   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6013
6014   arg1 = (Dali::Vector3 *)jarg1;
6015   {
6016     try {
6017       (arg1)->Normalize();
6018     } catch (std::out_of_range& e) {
6019       {
6020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6021       };
6022     } catch (std::exception& e) {
6023       {
6024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6025       };
6026     } catch (...) {
6027       {
6028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6029       };
6030     }
6031   }
6032 }
6033
6034
6035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6036   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6037   Dali::Vector3 *arg2 = 0 ;
6038   Dali::Vector3 *arg3 = 0 ;
6039
6040   arg1 = (Dali::Vector3 *)jarg1;
6041   arg2 = (Dali::Vector3 *)jarg2;
6042   if (!arg2) {
6043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6044     return ;
6045   }
6046   arg3 = (Dali::Vector3 *)jarg3;
6047   if (!arg3) {
6048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6049     return ;
6050   }
6051   {
6052     try {
6053       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6054     } catch (std::out_of_range& e) {
6055       {
6056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6057       };
6058     } catch (std::exception& e) {
6059       {
6060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6061       };
6062     } catch (...) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6065       };
6066     }
6067   }
6068 }
6069
6070
6071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6072   void * jresult ;
6073   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6074   float *result = 0 ;
6075
6076   arg1 = (Dali::Vector3 *)jarg1;
6077   {
6078     try {
6079       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6080     } catch (std::out_of_range& e) {
6081       {
6082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6083       };
6084     } catch (std::exception& e) {
6085       {
6086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6087       };
6088     } catch (...) {
6089       {
6090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6091       };
6092     }
6093   }
6094   jresult = (void *)result;
6095   return jresult;
6096 }
6097
6098
6099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6100   void * jresult ;
6101   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6102   Dali::Vector2 *result = 0 ;
6103
6104   arg1 = (Dali::Vector3 *)jarg1;
6105   {
6106     try {
6107       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6108     } catch (std::out_of_range& e) {
6109       {
6110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6111       };
6112     } catch (std::exception& e) {
6113       {
6114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6115       };
6116     } catch (...) {
6117       {
6118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6119       };
6120     }
6121   }
6122   jresult = (void *)result;
6123   return jresult;
6124 }
6125
6126
6127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6128   void * jresult ;
6129   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6130   Dali::Vector2 *result = 0 ;
6131
6132   arg1 = (Dali::Vector3 *)jarg1;
6133   {
6134     try {
6135       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6136     } catch (std::out_of_range& e) {
6137       {
6138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6139       };
6140     } catch (std::exception& e) {
6141       {
6142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6147       };
6148     }
6149   }
6150   jresult = (void *)result;
6151   return jresult;
6152 }
6153
6154
6155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6156   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6157   float arg2 ;
6158
6159   arg1 = (Dali::Vector3 *)jarg1;
6160   arg2 = (float)jarg2;
6161   if (arg1) (arg1)->x = arg2;
6162 }
6163
6164
6165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6166   float jresult ;
6167   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6168   float result;
6169
6170   arg1 = (Dali::Vector3 *)jarg1;
6171   result = (float) ((arg1)->x);
6172   jresult = result;
6173   return jresult;
6174 }
6175
6176
6177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6178   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6179   float arg2 ;
6180
6181   arg1 = (Dali::Vector3 *)jarg1;
6182   arg2 = (float)jarg2;
6183   if (arg1) (arg1)->width = arg2;
6184 }
6185
6186
6187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6188   float jresult ;
6189   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6190   float result;
6191
6192   arg1 = (Dali::Vector3 *)jarg1;
6193   result = (float) ((arg1)->width);
6194   jresult = result;
6195   return jresult;
6196 }
6197
6198
6199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6200   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6201   float arg2 ;
6202
6203   arg1 = (Dali::Vector3 *)jarg1;
6204   arg2 = (float)jarg2;
6205   if (arg1) (arg1)->r = arg2;
6206 }
6207
6208
6209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6210   float jresult ;
6211   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6212   float result;
6213
6214   arg1 = (Dali::Vector3 *)jarg1;
6215   result = (float) ((arg1)->r);
6216   jresult = result;
6217   return jresult;
6218 }
6219
6220
6221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6222   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6223   float arg2 ;
6224
6225   arg1 = (Dali::Vector3 *)jarg1;
6226   arg2 = (float)jarg2;
6227   if (arg1) (arg1)->y = arg2;
6228 }
6229
6230
6231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6232   float jresult ;
6233   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6234   float result;
6235
6236   arg1 = (Dali::Vector3 *)jarg1;
6237   result = (float) ((arg1)->y);
6238   jresult = result;
6239   return jresult;
6240 }
6241
6242
6243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6244   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6245   float arg2 ;
6246
6247   arg1 = (Dali::Vector3 *)jarg1;
6248   arg2 = (float)jarg2;
6249   if (arg1) (arg1)->height = arg2;
6250 }
6251
6252
6253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6254   float jresult ;
6255   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6256   float result;
6257
6258   arg1 = (Dali::Vector3 *)jarg1;
6259   result = (float) ((arg1)->height);
6260   jresult = result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6266   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6267   float arg2 ;
6268
6269   arg1 = (Dali::Vector3 *)jarg1;
6270   arg2 = (float)jarg2;
6271   if (arg1) (arg1)->g = arg2;
6272 }
6273
6274
6275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6276   float jresult ;
6277   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6278   float result;
6279
6280   arg1 = (Dali::Vector3 *)jarg1;
6281   result = (float) ((arg1)->g);
6282   jresult = result;
6283   return jresult;
6284 }
6285
6286
6287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6288   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6289   float arg2 ;
6290
6291   arg1 = (Dali::Vector3 *)jarg1;
6292   arg2 = (float)jarg2;
6293   if (arg1) (arg1)->z = arg2;
6294 }
6295
6296
6297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6298   float jresult ;
6299   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6300   float result;
6301
6302   arg1 = (Dali::Vector3 *)jarg1;
6303   result = (float) ((arg1)->z);
6304   jresult = result;
6305   return jresult;
6306 }
6307
6308
6309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6310   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6311   float arg2 ;
6312
6313   arg1 = (Dali::Vector3 *)jarg1;
6314   arg2 = (float)jarg2;
6315   if (arg1) (arg1)->depth = arg2;
6316 }
6317
6318
6319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6320   float jresult ;
6321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6322   float result;
6323
6324   arg1 = (Dali::Vector3 *)jarg1;
6325   result = (float) ((arg1)->depth);
6326   jresult = result;
6327   return jresult;
6328 }
6329
6330
6331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6332   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6333   float arg2 ;
6334
6335   arg1 = (Dali::Vector3 *)jarg1;
6336   arg2 = (float)jarg2;
6337   if (arg1) (arg1)->b = arg2;
6338 }
6339
6340
6341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6342   float jresult ;
6343   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6344   float result;
6345
6346   arg1 = (Dali::Vector3 *)jarg1;
6347   result = (float) ((arg1)->b);
6348   jresult = result;
6349   return jresult;
6350 }
6351
6352
6353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6354   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6355
6356   arg1 = (Dali::Vector3 *)jarg1;
6357   {
6358     try {
6359       delete arg1;
6360     } catch (std::out_of_range& e) {
6361       {
6362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6363       };
6364     } catch (std::exception& e) {
6365       {
6366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6367       };
6368     } catch (...) {
6369       {
6370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6371       };
6372     }
6373   }
6374 }
6375
6376
6377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6378   void * jresult ;
6379   Dali::Vector3 *arg1 = 0 ;
6380   Dali::Vector3 *arg2 = 0 ;
6381   Dali::Vector3 result;
6382
6383   arg1 = (Dali::Vector3 *)jarg1;
6384   if (!arg1) {
6385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6386     return 0;
6387   }
6388   arg2 = (Dali::Vector3 *)jarg2;
6389   if (!arg2) {
6390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6391     return 0;
6392   }
6393   {
6394     try {
6395       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6396     } catch (std::out_of_range& e) {
6397       {
6398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6399       };
6400     } catch (std::exception& e) {
6401       {
6402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6403       };
6404     } catch (...) {
6405       {
6406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6407       };
6408     }
6409   }
6410   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6416   void * jresult ;
6417   Dali::Vector3 *arg1 = 0 ;
6418   Dali::Vector3 *arg2 = 0 ;
6419   Dali::Vector3 result;
6420
6421   arg1 = (Dali::Vector3 *)jarg1;
6422   if (!arg1) {
6423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6424     return 0;
6425   }
6426   arg2 = (Dali::Vector3 *)jarg2;
6427   if (!arg2) {
6428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6429     return 0;
6430   }
6431   {
6432     try {
6433       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6434     } catch (std::out_of_range& e) {
6435       {
6436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6437       };
6438     } catch (std::exception& e) {
6439       {
6440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6441       };
6442     } catch (...) {
6443       {
6444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6445       };
6446     }
6447   }
6448   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6449   return jresult;
6450 }
6451
6452
6453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6454   void * jresult ;
6455   Dali::Vector3 *arg1 = 0 ;
6456   float *arg2 = 0 ;
6457   float *arg3 = 0 ;
6458   float temp2 ;
6459   float temp3 ;
6460   Dali::Vector3 result;
6461
6462   arg1 = (Dali::Vector3 *)jarg1;
6463   if (!arg1) {
6464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6465     return 0;
6466   }
6467   temp2 = (float)jarg2;
6468   arg2 = &temp2;
6469   temp3 = (float)jarg3;
6470   arg3 = &temp3;
6471   {
6472     try {
6473       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6474     } catch (std::out_of_range& e) {
6475       {
6476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6477       };
6478     } catch (std::exception& e) {
6479       {
6480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6481       };
6482     } catch (...) {
6483       {
6484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6485       };
6486     }
6487   }
6488   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6489   return jresult;
6490 }
6491
6492
6493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6494   void * jresult ;
6495   Dali::Vector4 *result = 0 ;
6496
6497   {
6498     try {
6499       result = (Dali::Vector4 *)new Dali::Vector4();
6500     } catch (std::out_of_range& e) {
6501       {
6502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (std::exception& e) {
6505       {
6506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6507       };
6508     } catch (...) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6511       };
6512     }
6513   }
6514   jresult = (void *)result;
6515   return jresult;
6516 }
6517
6518
6519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6520   void * jresult ;
6521   float arg1 ;
6522   float arg2 ;
6523   float arg3 ;
6524   float arg4 ;
6525   Dali::Vector4 *result = 0 ;
6526
6527   arg1 = (float)jarg1;
6528   arg2 = (float)jarg2;
6529   arg3 = (float)jarg3;
6530   arg4 = (float)jarg4;
6531   {
6532     try {
6533       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6534     } catch (std::out_of_range& e) {
6535       {
6536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6537       };
6538     } catch (std::exception& e) {
6539       {
6540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (...) {
6543       {
6544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6545       };
6546     }
6547   }
6548   jresult = (void *)result;
6549   return jresult;
6550 }
6551
6552
6553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6554   void * jresult ;
6555   float *arg1 = (float *) 0 ;
6556   Dali::Vector4 *result = 0 ;
6557
6558   arg1 = jarg1;
6559   {
6560     try {
6561       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6562     } catch (std::out_of_range& e) {
6563       {
6564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (std::exception& e) {
6567       {
6568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6569       };
6570     } catch (...) {
6571       {
6572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6573       };
6574     }
6575   }
6576   jresult = (void *)result;
6577
6578
6579   return jresult;
6580 }
6581
6582
6583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6584   void * jresult ;
6585   Dali::Vector2 *arg1 = 0 ;
6586   Dali::Vector4 *result = 0 ;
6587
6588   arg1 = (Dali::Vector2 *)jarg1;
6589   if (!arg1) {
6590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6591     return 0;
6592   }
6593   {
6594     try {
6595       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6596     } catch (std::out_of_range& e) {
6597       {
6598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6599       };
6600     } catch (std::exception& e) {
6601       {
6602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6603       };
6604     } catch (...) {
6605       {
6606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6607       };
6608     }
6609   }
6610   jresult = (void *)result;
6611   return jresult;
6612 }
6613
6614
6615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6616   void * jresult ;
6617   Dali::Vector3 *arg1 = 0 ;
6618   Dali::Vector4 *result = 0 ;
6619
6620   arg1 = (Dali::Vector3 *)jarg1;
6621   if (!arg1) {
6622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6623     return 0;
6624   }
6625   {
6626     try {
6627       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6628     } catch (std::out_of_range& e) {
6629       {
6630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6631       };
6632     } catch (std::exception& e) {
6633       {
6634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6635       };
6636     } catch (...) {
6637       {
6638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6639       };
6640     }
6641   }
6642   jresult = (void *)result;
6643   return jresult;
6644 }
6645
6646
6647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6648   void * jresult ;
6649   Dali::Vector4 *result = 0 ;
6650
6651   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6652   jresult = (void *)result;
6653   return jresult;
6654 }
6655
6656
6657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6658   void * jresult ;
6659   Dali::Vector4 *result = 0 ;
6660
6661   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6662   jresult = (void *)result;
6663   return jresult;
6664 }
6665
6666
6667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6668   void * jresult ;
6669   Dali::Vector4 *result = 0 ;
6670
6671   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6672   jresult = (void *)result;
6673   return jresult;
6674 }
6675
6676
6677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6678   void * jresult ;
6679   Dali::Vector4 *result = 0 ;
6680
6681   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6682   jresult = (void *)result;
6683   return jresult;
6684 }
6685
6686
6687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6688   void * jresult ;
6689   Dali::Vector4 *result = 0 ;
6690
6691   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6692   jresult = (void *)result;
6693   return jresult;
6694 }
6695
6696
6697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6698   void * jresult ;
6699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6700   float *arg2 = (float *) 0 ;
6701   Dali::Vector4 *result = 0 ;
6702
6703   arg1 = (Dali::Vector4 *)jarg1;
6704   arg2 = jarg2;
6705   {
6706     try {
6707       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6708     } catch (std::out_of_range& e) {
6709       {
6710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6711       };
6712     } catch (std::exception& e) {
6713       {
6714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (...) {
6717       {
6718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6719       };
6720     }
6721   }
6722   jresult = (void *)result;
6723
6724
6725   return jresult;
6726 }
6727
6728
6729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6730   void * jresult ;
6731   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6732   Dali::Vector2 *arg2 = 0 ;
6733   Dali::Vector4 *result = 0 ;
6734
6735   arg1 = (Dali::Vector4 *)jarg1;
6736   arg2 = (Dali::Vector2 *)jarg2;
6737   if (!arg2) {
6738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6739     return 0;
6740   }
6741   {
6742     try {
6743       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6744     } catch (std::out_of_range& e) {
6745       {
6746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6747       };
6748     } catch (std::exception& e) {
6749       {
6750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6751       };
6752     } catch (...) {
6753       {
6754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6755       };
6756     }
6757   }
6758   jresult = (void *)result;
6759   return jresult;
6760 }
6761
6762
6763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6764   void * jresult ;
6765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6766   Dali::Vector3 *arg2 = 0 ;
6767   Dali::Vector4 *result = 0 ;
6768
6769   arg1 = (Dali::Vector4 *)jarg1;
6770   arg2 = (Dali::Vector3 *)jarg2;
6771   if (!arg2) {
6772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6773     return 0;
6774   }
6775   {
6776     try {
6777       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6778     } catch (std::out_of_range& e) {
6779       {
6780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6781       };
6782     } catch (std::exception& e) {
6783       {
6784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6785       };
6786     } catch (...) {
6787       {
6788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6789       };
6790     }
6791   }
6792   jresult = (void *)result;
6793   return jresult;
6794 }
6795
6796
6797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6798   void * jresult ;
6799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6800   Dali::Vector4 *arg2 = 0 ;
6801   Dali::Vector4 result;
6802
6803   arg1 = (Dali::Vector4 *)jarg1;
6804   arg2 = (Dali::Vector4 *)jarg2;
6805   if (!arg2) {
6806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6807     return 0;
6808   }
6809   {
6810     try {
6811       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6812     } catch (std::out_of_range& e) {
6813       {
6814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6815       };
6816     } catch (std::exception& e) {
6817       {
6818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6819       };
6820     } catch (...) {
6821       {
6822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6823       };
6824     }
6825   }
6826   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6827   return jresult;
6828 }
6829
6830
6831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6832   void * jresult ;
6833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6834   Dali::Vector4 *arg2 = 0 ;
6835   Dali::Vector4 *result = 0 ;
6836
6837   arg1 = (Dali::Vector4 *)jarg1;
6838   arg2 = (Dali::Vector4 *)jarg2;
6839   if (!arg2) {
6840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6841     return 0;
6842   }
6843   {
6844     try {
6845       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6846     } catch (std::out_of_range& e) {
6847       {
6848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6849       };
6850     } catch (std::exception& e) {
6851       {
6852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6853       };
6854     } catch (...) {
6855       {
6856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6857       };
6858     }
6859   }
6860   jresult = (void *)result;
6861   return jresult;
6862 }
6863
6864
6865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6866   void * jresult ;
6867   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6868   Dali::Vector4 *arg2 = 0 ;
6869   Dali::Vector4 result;
6870
6871   arg1 = (Dali::Vector4 *)jarg1;
6872   arg2 = (Dali::Vector4 *)jarg2;
6873   if (!arg2) {
6874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6875     return 0;
6876   }
6877   {
6878     try {
6879       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6880     } catch (std::out_of_range& e) {
6881       {
6882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6883       };
6884     } catch (std::exception& e) {
6885       {
6886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6887       };
6888     } catch (...) {
6889       {
6890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6891       };
6892     }
6893   }
6894   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6895   return jresult;
6896 }
6897
6898
6899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6900   void * jresult ;
6901   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6902   Dali::Vector4 *arg2 = 0 ;
6903   Dali::Vector4 *result = 0 ;
6904
6905   arg1 = (Dali::Vector4 *)jarg1;
6906   arg2 = (Dali::Vector4 *)jarg2;
6907   if (!arg2) {
6908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6909     return 0;
6910   }
6911   {
6912     try {
6913       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6914     } catch (std::out_of_range& e) {
6915       {
6916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6917       };
6918     } catch (std::exception& e) {
6919       {
6920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6921       };
6922     } catch (...) {
6923       {
6924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6925       };
6926     }
6927   }
6928   jresult = (void *)result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6934   void * jresult ;
6935   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6936   Dali::Vector4 *arg2 = 0 ;
6937   Dali::Vector4 result;
6938
6939   arg1 = (Dali::Vector4 *)jarg1;
6940   arg2 = (Dali::Vector4 *)jarg2;
6941   if (!arg2) {
6942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6943     return 0;
6944   }
6945   {
6946     try {
6947       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6948     } catch (std::out_of_range& e) {
6949       {
6950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6951       };
6952     } catch (std::exception& e) {
6953       {
6954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6955       };
6956     } catch (...) {
6957       {
6958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6959       };
6960     }
6961   }
6962   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6963   return jresult;
6964 }
6965
6966
6967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6968   void * jresult ;
6969   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6970   float arg2 ;
6971   Dali::Vector4 result;
6972
6973   arg1 = (Dali::Vector4 *)jarg1;
6974   arg2 = (float)jarg2;
6975   {
6976     try {
6977       result = ((Dali::Vector4 const *)arg1)->operator *(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 = new Dali::Vector4((const Dali::Vector4 &)result);
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__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 = 0 ;
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 *) &(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 = (void *)result;
7027   return jresult;
7028 }
7029
7030
7031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7032   void * jresult ;
7033   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7034   float arg2 ;
7035   Dali::Vector4 *result = 0 ;
7036
7037   arg1 = (Dali::Vector4 *)jarg1;
7038   arg2 = (float)jarg2;
7039   {
7040     try {
7041       result = (Dali::Vector4 *) &(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 = (void *)result;
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__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;
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 const *)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 = new Dali::Vector4((const Dali::Vector4 &)result);
7091   return jresult;
7092 }
7093
7094
7095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7096   void * jresult ;
7097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7098   float arg2 ;
7099   Dali::Vector4 result;
7100
7101   arg1 = (Dali::Vector4 *)jarg1;
7102   arg2 = (float)jarg2;
7103   {
7104     try {
7105       result = ((Dali::Vector4 const *)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 = new Dali::Vector4((const Dali::Vector4 &)result);
7121   return jresult;
7122 }
7123
7124
7125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__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 = 0 ;
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 *) &(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 = (void *)result;
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7160   void * jresult ;
7161   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7162   float arg2 ;
7163   Dali::Vector4 *result = 0 ;
7164
7165   arg1 = (Dali::Vector4 *)jarg1;
7166   arg2 = (float)jarg2;
7167   {
7168     try {
7169       result = (Dali::Vector4 *) &(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 = (void *)result;
7185   return jresult;
7186 }
7187
7188
7189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7190   void * jresult ;
7191   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7192   Dali::Vector4 result;
7193
7194   arg1 = (Dali::Vector4 *)jarg1;
7195   {
7196     try {
7197       result = ((Dali::Vector4 const *)arg1)->operator -();
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (...) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7209       };
7210     }
7211   }
7212   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7213   return jresult;
7214 }
7215
7216
7217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7218   unsigned int jresult ;
7219   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7220   Dali::Vector4 *arg2 = 0 ;
7221   bool result;
7222
7223   arg1 = (Dali::Vector4 *)jarg1;
7224   arg2 = (Dali::Vector4 *)jarg2;
7225   if (!arg2) {
7226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7227     return 0;
7228   }
7229   {
7230     try {
7231       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7232     } catch (std::out_of_range& e) {
7233       {
7234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7235       };
7236     } catch (std::exception& e) {
7237       {
7238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7239       };
7240     } catch (...) {
7241       {
7242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7243       };
7244     }
7245   }
7246   jresult = result;
7247   return jresult;
7248 }
7249
7250
7251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7252   unsigned int jresult ;
7253   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7254   Dali::Vector4 *arg2 = 0 ;
7255   bool result;
7256
7257   arg1 = (Dali::Vector4 *)jarg1;
7258   arg2 = (Dali::Vector4 *)jarg2;
7259   if (!arg2) {
7260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7261     return 0;
7262   }
7263   {
7264     try {
7265       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7266     } catch (std::out_of_range& e) {
7267       {
7268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7269       };
7270     } catch (std::exception& e) {
7271       {
7272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7273       };
7274     } catch (...) {
7275       {
7276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7277       };
7278     }
7279   }
7280   jresult = result;
7281   return jresult;
7282 }
7283
7284
7285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7286   float jresult ;
7287   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7288   unsigned int arg2 ;
7289   float *result = 0 ;
7290
7291   arg1 = (Dali::Vector4 *)jarg1;
7292   arg2 = (unsigned int)jarg2;
7293   {
7294     try {
7295       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](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 float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7316   float jresult ;
7317   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7318   Dali::Vector3 *arg2 = 0 ;
7319   float result;
7320
7321   arg1 = (Dali::Vector4 *)jarg1;
7322   arg2 = (Dali::Vector3 *)jarg2;
7323   if (!arg2) {
7324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7325     return 0;
7326   }
7327   {
7328     try {
7329       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 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_Dot__SWIG_1(void * jarg1, void * jarg2) {
7350   float jresult ;
7351   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7352   Dali::Vector4 *arg2 = 0 ;
7353   float result;
7354
7355   arg1 = (Dali::Vector4 *)jarg1;
7356   arg2 = (Dali::Vector4 *)jarg2;
7357   if (!arg2) {
7358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7359     return 0;
7360   }
7361   {
7362     try {
7363       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7364     } catch (std::out_of_range& e) {
7365       {
7366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7367       };
7368     } catch (std::exception& e) {
7369       {
7370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7371       };
7372     } catch (...) {
7373       {
7374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7375       };
7376     }
7377   }
7378   jresult = result;
7379   return jresult;
7380 }
7381
7382
7383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7384   float jresult ;
7385   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7386   Dali::Vector4 *arg2 = 0 ;
7387   float result;
7388
7389   arg1 = (Dali::Vector4 *)jarg1;
7390   arg2 = (Dali::Vector4 *)jarg2;
7391   if (!arg2) {
7392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7393     return 0;
7394   }
7395   {
7396     try {
7397       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7398     } catch (std::out_of_range& e) {
7399       {
7400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7401       };
7402     } catch (std::exception& e) {
7403       {
7404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7405       };
7406     } catch (...) {
7407       {
7408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7409       };
7410     }
7411   }
7412   jresult = result;
7413   return jresult;
7414 }
7415
7416
7417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7418   void * jresult ;
7419   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7420   Dali::Vector4 *arg2 = 0 ;
7421   Dali::Vector4 result;
7422
7423   arg1 = (Dali::Vector4 *)jarg1;
7424   arg2 = (Dali::Vector4 *)jarg2;
7425   if (!arg2) {
7426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7427     return 0;
7428   }
7429   {
7430     try {
7431       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7432     } catch (std::out_of_range& e) {
7433       {
7434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7435       };
7436     } catch (std::exception& e) {
7437       {
7438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7439       };
7440     } catch (...) {
7441       {
7442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7443       };
7444     }
7445   }
7446   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7452   float jresult ;
7453   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7454   float result;
7455
7456   arg1 = (Dali::Vector4 *)jarg1;
7457   {
7458     try {
7459       result = (float)((Dali::Vector4 const *)arg1)->Length();
7460     } catch (std::out_of_range& e) {
7461       {
7462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7463       };
7464     } catch (std::exception& e) {
7465       {
7466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7467       };
7468     } catch (...) {
7469       {
7470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7471       };
7472     }
7473   }
7474   jresult = result;
7475   return jresult;
7476 }
7477
7478
7479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7480   float jresult ;
7481   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7482   float result;
7483
7484   arg1 = (Dali::Vector4 *)jarg1;
7485   {
7486     try {
7487       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7488     } catch (std::out_of_range& e) {
7489       {
7490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7491       };
7492     } catch (std::exception& e) {
7493       {
7494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7495       };
7496     } catch (...) {
7497       {
7498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7499       };
7500     }
7501   }
7502   jresult = result;
7503   return jresult;
7504 }
7505
7506
7507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7508   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7509
7510   arg1 = (Dali::Vector4 *)jarg1;
7511   {
7512     try {
7513       (arg1)->Normalize();
7514     } catch (std::out_of_range& e) {
7515       {
7516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7517       };
7518     } catch (std::exception& e) {
7519       {
7520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7521       };
7522     } catch (...) {
7523       {
7524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7525       };
7526     }
7527   }
7528 }
7529
7530
7531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7533   Dali::Vector4 *arg2 = 0 ;
7534   Dali::Vector4 *arg3 = 0 ;
7535
7536   arg1 = (Dali::Vector4 *)jarg1;
7537   arg2 = (Dali::Vector4 *)jarg2;
7538   if (!arg2) {
7539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7540     return ;
7541   }
7542   arg3 = (Dali::Vector4 *)jarg3;
7543   if (!arg3) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7545     return ;
7546   }
7547   {
7548     try {
7549       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7557       };
7558     } catch (...) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7561       };
7562     }
7563   }
7564 }
7565
7566
7567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7568   void * jresult ;
7569   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7570   float *result = 0 ;
7571
7572   arg1 = (Dali::Vector4 *)jarg1;
7573   {
7574     try {
7575       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7576     } catch (std::out_of_range& e) {
7577       {
7578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7579       };
7580     } catch (std::exception& e) {
7581       {
7582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7583       };
7584     } catch (...) {
7585       {
7586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7587       };
7588     }
7589   }
7590   jresult = (void *)result;
7591   return jresult;
7592 }
7593
7594
7595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7596   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7597   float arg2 ;
7598
7599   arg1 = (Dali::Vector4 *)jarg1;
7600   arg2 = (float)jarg2;
7601   if (arg1) (arg1)->x = arg2;
7602 }
7603
7604
7605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7606   float jresult ;
7607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7608   float result;
7609
7610   arg1 = (Dali::Vector4 *)jarg1;
7611   result = (float) ((arg1)->x);
7612   jresult = result;
7613   return jresult;
7614 }
7615
7616
7617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7618   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7619   float arg2 ;
7620
7621   arg1 = (Dali::Vector4 *)jarg1;
7622   arg2 = (float)jarg2;
7623   if (arg1) (arg1)->r = arg2;
7624 }
7625
7626
7627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7628   float jresult ;
7629   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7630   float result;
7631
7632   arg1 = (Dali::Vector4 *)jarg1;
7633   result = (float) ((arg1)->r);
7634   jresult = result;
7635   return jresult;
7636 }
7637
7638
7639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7640   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7641   float arg2 ;
7642
7643   arg1 = (Dali::Vector4 *)jarg1;
7644   arg2 = (float)jarg2;
7645   if (arg1) (arg1)->s = arg2;
7646 }
7647
7648
7649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7650   float jresult ;
7651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7652   float result;
7653
7654   arg1 = (Dali::Vector4 *)jarg1;
7655   result = (float) ((arg1)->s);
7656   jresult = result;
7657   return jresult;
7658 }
7659
7660
7661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7662   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7663   float arg2 ;
7664
7665   arg1 = (Dali::Vector4 *)jarg1;
7666   arg2 = (float)jarg2;
7667   if (arg1) (arg1)->y = arg2;
7668 }
7669
7670
7671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7672   float jresult ;
7673   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7674   float result;
7675
7676   arg1 = (Dali::Vector4 *)jarg1;
7677   result = (float) ((arg1)->y);
7678   jresult = result;
7679   return jresult;
7680 }
7681
7682
7683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7684   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7685   float arg2 ;
7686
7687   arg1 = (Dali::Vector4 *)jarg1;
7688   arg2 = (float)jarg2;
7689   if (arg1) (arg1)->g = arg2;
7690 }
7691
7692
7693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7694   float jresult ;
7695   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7696   float result;
7697
7698   arg1 = (Dali::Vector4 *)jarg1;
7699   result = (float) ((arg1)->g);
7700   jresult = result;
7701   return jresult;
7702 }
7703
7704
7705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7706   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7707   float arg2 ;
7708
7709   arg1 = (Dali::Vector4 *)jarg1;
7710   arg2 = (float)jarg2;
7711   if (arg1) (arg1)->t = arg2;
7712 }
7713
7714
7715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7716   float jresult ;
7717   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7718   float result;
7719
7720   arg1 = (Dali::Vector4 *)jarg1;
7721   result = (float) ((arg1)->t);
7722   jresult = result;
7723   return jresult;
7724 }
7725
7726
7727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7728   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7729   float arg2 ;
7730
7731   arg1 = (Dali::Vector4 *)jarg1;
7732   arg2 = (float)jarg2;
7733   if (arg1) (arg1)->z = arg2;
7734 }
7735
7736
7737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7738   float jresult ;
7739   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7740   float result;
7741
7742   arg1 = (Dali::Vector4 *)jarg1;
7743   result = (float) ((arg1)->z);
7744   jresult = result;
7745   return jresult;
7746 }
7747
7748
7749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7750   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7751   float arg2 ;
7752
7753   arg1 = (Dali::Vector4 *)jarg1;
7754   arg2 = (float)jarg2;
7755   if (arg1) (arg1)->b = arg2;
7756 }
7757
7758
7759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7760   float jresult ;
7761   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7762   float result;
7763
7764   arg1 = (Dali::Vector4 *)jarg1;
7765   result = (float) ((arg1)->b);
7766   jresult = result;
7767   return jresult;
7768 }
7769
7770
7771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7772   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7773   float arg2 ;
7774
7775   arg1 = (Dali::Vector4 *)jarg1;
7776   arg2 = (float)jarg2;
7777   if (arg1) (arg1)->p = arg2;
7778 }
7779
7780
7781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7782   float jresult ;
7783   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7784   float result;
7785
7786   arg1 = (Dali::Vector4 *)jarg1;
7787   result = (float) ((arg1)->p);
7788   jresult = result;
7789   return jresult;
7790 }
7791
7792
7793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7794   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7795   float arg2 ;
7796
7797   arg1 = (Dali::Vector4 *)jarg1;
7798   arg2 = (float)jarg2;
7799   if (arg1) (arg1)->w = arg2;
7800 }
7801
7802
7803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7804   float jresult ;
7805   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7806   float result;
7807
7808   arg1 = (Dali::Vector4 *)jarg1;
7809   result = (float) ((arg1)->w);
7810   jresult = result;
7811   return jresult;
7812 }
7813
7814
7815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7816   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7817   float arg2 ;
7818
7819   arg1 = (Dali::Vector4 *)jarg1;
7820   arg2 = (float)jarg2;
7821   if (arg1) (arg1)->a = arg2;
7822 }
7823
7824
7825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7826   float jresult ;
7827   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7828   float result;
7829
7830   arg1 = (Dali::Vector4 *)jarg1;
7831   result = (float) ((arg1)->a);
7832   jresult = result;
7833   return jresult;
7834 }
7835
7836
7837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7838   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7839   float arg2 ;
7840
7841   arg1 = (Dali::Vector4 *)jarg1;
7842   arg2 = (float)jarg2;
7843   if (arg1) (arg1)->q = arg2;
7844 }
7845
7846
7847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7848   float jresult ;
7849   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7850   float result;
7851
7852   arg1 = (Dali::Vector4 *)jarg1;
7853   result = (float) ((arg1)->q);
7854   jresult = result;
7855   return jresult;
7856 }
7857
7858
7859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7860   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7861
7862   arg1 = (Dali::Vector4 *)jarg1;
7863   {
7864     try {
7865       delete arg1;
7866     } catch (std::out_of_range& e) {
7867       {
7868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7869       };
7870     } catch (std::exception& e) {
7871       {
7872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7873       };
7874     } catch (...) {
7875       {
7876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7877       };
7878     }
7879   }
7880 }
7881
7882
7883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7884   void * jresult ;
7885   Dali::Vector4 *arg1 = 0 ;
7886   Dali::Vector4 *arg2 = 0 ;
7887   Dali::Vector4 result;
7888
7889   arg1 = (Dali::Vector4 *)jarg1;
7890   if (!arg1) {
7891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7892     return 0;
7893   }
7894   arg2 = (Dali::Vector4 *)jarg2;
7895   if (!arg2) {
7896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7897     return 0;
7898   }
7899   {
7900     try {
7901       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7902     } catch (std::out_of_range& e) {
7903       {
7904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7905       };
7906     } catch (std::exception& e) {
7907       {
7908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7909       };
7910     } catch (...) {
7911       {
7912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7913       };
7914     }
7915   }
7916   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7917   return jresult;
7918 }
7919
7920
7921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7922   void * jresult ;
7923   Dali::Vector4 *arg1 = 0 ;
7924   Dali::Vector4 *arg2 = 0 ;
7925   Dali::Vector4 result;
7926
7927   arg1 = (Dali::Vector4 *)jarg1;
7928   if (!arg1) {
7929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7930     return 0;
7931   }
7932   arg2 = (Dali::Vector4 *)jarg2;
7933   if (!arg2) {
7934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7935     return 0;
7936   }
7937   {
7938     try {
7939       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7940     } catch (std::out_of_range& e) {
7941       {
7942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7943       };
7944     } catch (std::exception& e) {
7945       {
7946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7947       };
7948     } catch (...) {
7949       {
7950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7951       };
7952     }
7953   }
7954   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7955   return jresult;
7956 }
7957
7958
7959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7960   void * jresult ;
7961   Dali::Vector4 *arg1 = 0 ;
7962   float *arg2 = 0 ;
7963   float *arg3 = 0 ;
7964   float temp2 ;
7965   float temp3 ;
7966   Dali::Vector4 result;
7967
7968   arg1 = (Dali::Vector4 *)jarg1;
7969   if (!arg1) {
7970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7971     return 0;
7972   }
7973   temp2 = (float)jarg2;
7974   arg2 = &temp2;
7975   temp3 = (float)jarg3;
7976   arg3 = &temp3;
7977   {
7978     try {
7979       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7980     } catch (std::out_of_range& e) {
7981       {
7982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7983       };
7984     } catch (std::exception& e) {
7985       {
7986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7987       };
7988     } catch (...) {
7989       {
7990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7991       };
7992     }
7993   }
7994   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7995   return jresult;
7996 }
7997
7998
7999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8000   void * jresult ;
8001   Dali::Uint16Pair *result = 0 ;
8002
8003   {
8004     try {
8005       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8006     } catch (std::out_of_range& e) {
8007       {
8008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (std::exception& e) {
8011       {
8012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (...) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8017       };
8018     }
8019   }
8020   jresult = (void *)result;
8021   return jresult;
8022 }
8023
8024
8025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8026   void * jresult ;
8027   uint32_t arg1 ;
8028   uint32_t arg2 ;
8029   Dali::Uint16Pair *result = 0 ;
8030
8031   arg1 = (uint32_t)jarg1;
8032   arg2 = (uint32_t)jarg2;
8033   {
8034     try {
8035       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8036     } catch (std::out_of_range& e) {
8037       {
8038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8039       };
8040     } catch (std::exception& e) {
8041       {
8042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8043       };
8044     } catch (...) {
8045       {
8046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8047       };
8048     }
8049   }
8050   jresult = (void *)result;
8051   return jresult;
8052 }
8053
8054
8055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8056   void * jresult ;
8057   Dali::Uint16Pair *arg1 = 0 ;
8058   Dali::Uint16Pair *result = 0 ;
8059
8060   arg1 = (Dali::Uint16Pair *)jarg1;
8061   if (!arg1) {
8062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8063     return 0;
8064   }
8065   {
8066     try {
8067       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8068     } catch (std::out_of_range& e) {
8069       {
8070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (std::exception& e) {
8073       {
8074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (...) {
8077       {
8078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8079       };
8080     }
8081   }
8082   jresult = (void *)result;
8083   return jresult;
8084 }
8085
8086
8087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8088   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8089   uint16_t arg2 ;
8090
8091   arg1 = (Dali::Uint16Pair *)jarg1;
8092   arg2 = (uint16_t)jarg2;
8093   {
8094     try {
8095       (arg1)->SetWidth(arg2);
8096     } catch (std::out_of_range& e) {
8097       {
8098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8099       };
8100     } catch (std::exception& e) {
8101       {
8102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8103       };
8104     } catch (...) {
8105       {
8106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8107       };
8108     }
8109   }
8110 }
8111
8112
8113 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8114   unsigned short jresult ;
8115   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8116   uint16_t result;
8117
8118   arg1 = (Dali::Uint16Pair *)jarg1;
8119   {
8120     try {
8121       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8122     } catch (std::out_of_range& e) {
8123       {
8124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8125       };
8126     } catch (std::exception& e) {
8127       {
8128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8129       };
8130     } catch (...) {
8131       {
8132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8133       };
8134     }
8135   }
8136   jresult = result;
8137   return jresult;
8138 }
8139
8140
8141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8142   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8143   uint16_t arg2 ;
8144
8145   arg1 = (Dali::Uint16Pair *)jarg1;
8146   arg2 = (uint16_t)jarg2;
8147   {
8148     try {
8149       (arg1)->SetHeight(arg2);
8150     } catch (std::out_of_range& e) {
8151       {
8152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8153       };
8154     } catch (std::exception& e) {
8155       {
8156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8157       };
8158     } catch (...) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8161       };
8162     }
8163   }
8164 }
8165
8166
8167 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8168   unsigned short jresult ;
8169   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8170   uint16_t result;
8171
8172   arg1 = (Dali::Uint16Pair *)jarg1;
8173   {
8174     try {
8175       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8176     } catch (std::out_of_range& e) {
8177       {
8178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8179       };
8180     } catch (std::exception& e) {
8181       {
8182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8183       };
8184     } catch (...) {
8185       {
8186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8187       };
8188     }
8189   }
8190   jresult = result;
8191   return jresult;
8192 }
8193
8194
8195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8196   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8197   uint16_t arg2 ;
8198
8199   arg1 = (Dali::Uint16Pair *)jarg1;
8200   arg2 = (uint16_t)jarg2;
8201   {
8202     try {
8203       (arg1)->SetX(arg2);
8204     } catch (std::out_of_range& e) {
8205       {
8206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8207       };
8208     } catch (std::exception& e) {
8209       {
8210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8211       };
8212     } catch (...) {
8213       {
8214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8215       };
8216     }
8217   }
8218 }
8219
8220
8221 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8222   unsigned short jresult ;
8223   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8224   uint16_t result;
8225
8226   arg1 = (Dali::Uint16Pair *)jarg1;
8227   {
8228     try {
8229       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8230     } catch (std::out_of_range& e) {
8231       {
8232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8233       };
8234     } catch (std::exception& e) {
8235       {
8236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8237       };
8238     } catch (...) {
8239       {
8240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8241       };
8242     }
8243   }
8244   jresult = result;
8245   return jresult;
8246 }
8247
8248
8249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8250   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8251   uint16_t arg2 ;
8252
8253   arg1 = (Dali::Uint16Pair *)jarg1;
8254   arg2 = (uint16_t)jarg2;
8255   {
8256     try {
8257       (arg1)->SetY(arg2);
8258     } catch (std::out_of_range& e) {
8259       {
8260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8261       };
8262     } catch (std::exception& e) {
8263       {
8264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8265       };
8266     } catch (...) {
8267       {
8268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8269       };
8270     }
8271   }
8272 }
8273
8274
8275 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8276   unsigned short jresult ;
8277   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8278   uint16_t result;
8279
8280   arg1 = (Dali::Uint16Pair *)jarg1;
8281   {
8282     try {
8283       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8284     } catch (std::out_of_range& e) {
8285       {
8286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8287       };
8288     } catch (std::exception& e) {
8289       {
8290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8291       };
8292     } catch (...) {
8293       {
8294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8295       };
8296     }
8297   }
8298   jresult = result;
8299   return jresult;
8300 }
8301
8302
8303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8304   void * jresult ;
8305   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8306   Dali::Uint16Pair *arg2 = 0 ;
8307   Dali::Uint16Pair *result = 0 ;
8308
8309   arg1 = (Dali::Uint16Pair *)jarg1;
8310   arg2 = (Dali::Uint16Pair *)jarg2;
8311   if (!arg2) {
8312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8313     return 0;
8314   }
8315   {
8316     try {
8317       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8318     } catch (std::out_of_range& e) {
8319       {
8320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8321       };
8322     } catch (std::exception& e) {
8323       {
8324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8325       };
8326     } catch (...) {
8327       {
8328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8329       };
8330     }
8331   }
8332   jresult = (void *)result;
8333   return jresult;
8334 }
8335
8336
8337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8338   unsigned int jresult ;
8339   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8340   Dali::Uint16Pair *arg2 = 0 ;
8341   bool result;
8342
8343   arg1 = (Dali::Uint16Pair *)jarg1;
8344   arg2 = (Dali::Uint16Pair *)jarg2;
8345   if (!arg2) {
8346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8347     return 0;
8348   }
8349   {
8350     try {
8351       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8352     } catch (std::out_of_range& e) {
8353       {
8354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8355       };
8356     } catch (std::exception& e) {
8357       {
8358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8359       };
8360     } catch (...) {
8361       {
8362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8363       };
8364     }
8365   }
8366   jresult = result;
8367   return jresult;
8368 }
8369
8370
8371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8372   unsigned int jresult ;
8373   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8374   Dali::Uint16Pair *arg2 = 0 ;
8375   bool result;
8376
8377   arg1 = (Dali::Uint16Pair *)jarg1;
8378   arg2 = (Dali::Uint16Pair *)jarg2;
8379   if (!arg2) {
8380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8381     return 0;
8382   }
8383   {
8384     try {
8385       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8386     } catch (std::out_of_range& e) {
8387       {
8388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8389       };
8390     } catch (std::exception& e) {
8391       {
8392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8393       };
8394     } catch (...) {
8395       {
8396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8397       };
8398     }
8399   }
8400   jresult = result;
8401   return jresult;
8402 }
8403
8404
8405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8406   unsigned int jresult ;
8407   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8408   Dali::Uint16Pair *arg2 = 0 ;
8409   bool result;
8410
8411   arg1 = (Dali::Uint16Pair *)jarg1;
8412   arg2 = (Dali::Uint16Pair *)jarg2;
8413   if (!arg2) {
8414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8415     return 0;
8416   }
8417   {
8418     try {
8419       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8420     } catch (std::out_of_range& e) {
8421       {
8422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8423       };
8424     } catch (std::exception& e) {
8425       {
8426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8427       };
8428     } catch (...) {
8429       {
8430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8431       };
8432     }
8433   }
8434   jresult = result;
8435   return jresult;
8436 }
8437
8438
8439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8440   unsigned int jresult ;
8441   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8442   Dali::Uint16Pair *arg2 = 0 ;
8443   bool result;
8444
8445   arg1 = (Dali::Uint16Pair *)jarg1;
8446   arg2 = (Dali::Uint16Pair *)jarg2;
8447   if (!arg2) {
8448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8449     return 0;
8450   }
8451   {
8452     try {
8453       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8454     } catch (std::out_of_range& e) {
8455       {
8456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8457       };
8458     } catch (std::exception& e) {
8459       {
8460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8461       };
8462     } catch (...) {
8463       {
8464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8465       };
8466     }
8467   }
8468   jresult = result;
8469   return jresult;
8470 }
8471
8472
8473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8474   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8475
8476   arg1 = (Dali::Uint16Pair *)jarg1;
8477   {
8478     try {
8479       delete arg1;
8480     } catch (std::out_of_range& e) {
8481       {
8482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8483       };
8484     } catch (std::exception& e) {
8485       {
8486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8487       };
8488     } catch (...) {
8489       {
8490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8491       };
8492     }
8493   }
8494 }
8495
8496
8497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8498   void * jresult ;
8499   Dali::Degree *result = 0 ;
8500
8501   {
8502     try {
8503       result = (Dali::Degree *)new Dali::Degree();
8504     } catch (std::out_of_range& e) {
8505       {
8506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (std::exception& e) {
8509       {
8510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (...) {
8513       {
8514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8515       };
8516     }
8517   }
8518   jresult = (void *)result;
8519   return jresult;
8520 }
8521
8522
8523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8524   void * jresult ;
8525   float arg1 ;
8526   Dali::Degree *result = 0 ;
8527
8528   arg1 = (float)jarg1;
8529   {
8530     try {
8531       result = (Dali::Degree *)new Dali::Degree(arg1);
8532     } catch (std::out_of_range& e) {
8533       {
8534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8535       };
8536     } catch (std::exception& e) {
8537       {
8538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8539       };
8540     } catch (...) {
8541       {
8542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8543       };
8544     }
8545   }
8546   jresult = (void *)result;
8547   return jresult;
8548 }
8549
8550
8551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8552   void * jresult ;
8553   Dali::Radian arg1 ;
8554   Dali::Radian *argp1 ;
8555   Dali::Degree *result = 0 ;
8556
8557   argp1 = (Dali::Radian *)jarg1;
8558   if (!argp1) {
8559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8560     return 0;
8561   }
8562   arg1 = *argp1;
8563   {
8564     try {
8565       result = (Dali::Degree *)new Dali::Degree(arg1);
8566     } catch (std::out_of_range& e) {
8567       {
8568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8569       };
8570     } catch (std::exception& e) {
8571       {
8572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8573       };
8574     } catch (...) {
8575       {
8576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8577       };
8578     }
8579   }
8580   jresult = (void *)result;
8581   return jresult;
8582 }
8583
8584
8585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8586   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8587   float arg2 ;
8588
8589   arg1 = (Dali::Degree *)jarg1;
8590   arg2 = (float)jarg2;
8591   if (arg1) (arg1)->degree = arg2;
8592 }
8593
8594
8595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8596   float jresult ;
8597   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8598   float result;
8599
8600   arg1 = (Dali::Degree *)jarg1;
8601   result = (float) ((arg1)->degree);
8602   jresult = result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8608   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8609
8610   arg1 = (Dali::Degree *)jarg1;
8611   {
8612     try {
8613       delete arg1;
8614     } catch (std::out_of_range& e) {
8615       {
8616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8617       };
8618     } catch (std::exception& e) {
8619       {
8620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8621       };
8622     } catch (...) {
8623       {
8624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8625       };
8626     }
8627   }
8628 }
8629
8630
8631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8632   void * jresult ;
8633   Dali::Radian *result = 0 ;
8634
8635   result = (Dali::Radian *)&Dali::ANGLE_360;
8636   jresult = (void *)result;
8637   return jresult;
8638 }
8639
8640
8641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8642   void * jresult ;
8643   Dali::Radian *result = 0 ;
8644
8645   result = (Dali::Radian *)&Dali::ANGLE_315;
8646   jresult = (void *)result;
8647   return jresult;
8648 }
8649
8650
8651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8652   void * jresult ;
8653   Dali::Radian *result = 0 ;
8654
8655   result = (Dali::Radian *)&Dali::ANGLE_270;
8656   jresult = (void *)result;
8657   return jresult;
8658 }
8659
8660
8661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8662   void * jresult ;
8663   Dali::Radian *result = 0 ;
8664
8665   result = (Dali::Radian *)&Dali::ANGLE_225;
8666   jresult = (void *)result;
8667   return jresult;
8668 }
8669
8670
8671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8672   void * jresult ;
8673   Dali::Radian *result = 0 ;
8674
8675   result = (Dali::Radian *)&Dali::ANGLE_180;
8676   jresult = (void *)result;
8677   return jresult;
8678 }
8679
8680
8681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8682   void * jresult ;
8683   Dali::Radian *result = 0 ;
8684
8685   result = (Dali::Radian *)&Dali::ANGLE_135;
8686   jresult = (void *)result;
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8692   void * jresult ;
8693   Dali::Radian *result = 0 ;
8694
8695   result = (Dali::Radian *)&Dali::ANGLE_120;
8696   jresult = (void *)result;
8697   return jresult;
8698 }
8699
8700
8701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8702   void * jresult ;
8703   Dali::Radian *result = 0 ;
8704
8705   result = (Dali::Radian *)&Dali::ANGLE_90;
8706   jresult = (void *)result;
8707   return jresult;
8708 }
8709
8710
8711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8712   void * jresult ;
8713   Dali::Radian *result = 0 ;
8714
8715   result = (Dali::Radian *)&Dali::ANGLE_60;
8716   jresult = (void *)result;
8717   return jresult;
8718 }
8719
8720
8721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8722   void * jresult ;
8723   Dali::Radian *result = 0 ;
8724
8725   result = (Dali::Radian *)&Dali::ANGLE_45;
8726   jresult = (void *)result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8732   void * jresult ;
8733   Dali::Radian *result = 0 ;
8734
8735   result = (Dali::Radian *)&Dali::ANGLE_30;
8736   jresult = (void *)result;
8737   return jresult;
8738 }
8739
8740
8741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8742   void * jresult ;
8743   Dali::Radian *result = 0 ;
8744
8745   result = (Dali::Radian *)&Dali::ANGLE_0;
8746   jresult = (void *)result;
8747   return jresult;
8748 }
8749
8750
8751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8752   unsigned int jresult ;
8753   Dali::Degree *arg1 = 0 ;
8754   Dali::Degree *arg2 = 0 ;
8755   bool result;
8756
8757   arg1 = (Dali::Degree *)jarg1;
8758   if (!arg1) {
8759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8760     return 0;
8761   }
8762   arg2 = (Dali::Degree *)jarg2;
8763   if (!arg2) {
8764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8765     return 0;
8766   }
8767   {
8768     try {
8769       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8770     } catch (std::out_of_range& e) {
8771       {
8772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8773       };
8774     } catch (std::exception& e) {
8775       {
8776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8777       };
8778     } catch (...) {
8779       {
8780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8781       };
8782     }
8783   }
8784   jresult = result;
8785   return jresult;
8786 }
8787
8788
8789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8790   unsigned int jresult ;
8791   Dali::Degree *arg1 = 0 ;
8792   Dali::Degree *arg2 = 0 ;
8793   bool result;
8794
8795   arg1 = (Dali::Degree *)jarg1;
8796   if (!arg1) {
8797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8798     return 0;
8799   }
8800   arg2 = (Dali::Degree *)jarg2;
8801   if (!arg2) {
8802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8803     return 0;
8804   }
8805   {
8806     try {
8807       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8808     } catch (std::out_of_range& e) {
8809       {
8810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8811       };
8812     } catch (std::exception& e) {
8813       {
8814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8815       };
8816     } catch (...) {
8817       {
8818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8819       };
8820     }
8821   }
8822   jresult = result;
8823   return jresult;
8824 }
8825
8826
8827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8828   void * jresult ;
8829   Dali::Degree arg1 ;
8830   float arg2 ;
8831   float arg3 ;
8832   Dali::Degree *argp1 ;
8833   Dali::Degree result;
8834
8835   argp1 = (Dali::Degree *)jarg1;
8836   if (!argp1) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8838     return 0;
8839   }
8840   arg1 = *argp1;
8841   arg2 = (float)jarg2;
8842   arg3 = (float)jarg3;
8843   {
8844     try {
8845       result = Dali::Clamp(arg1,arg2,arg3);
8846     } catch (std::out_of_range& e) {
8847       {
8848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (std::exception& e) {
8851       {
8852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8853       };
8854     } catch (...) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8857       };
8858     }
8859   }
8860   jresult = new Dali::Degree((const Dali::Degree &)result);
8861   return jresult;
8862 }
8863
8864
8865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8866   void * jresult ;
8867   Dali::Radian *result = 0 ;
8868
8869   {
8870     try {
8871       result = (Dali::Radian *)new Dali::Radian();
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 = (void *)result;
8887   return jresult;
8888 }
8889
8890
8891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8892   void * jresult ;
8893   float arg1 ;
8894   Dali::Radian *result = 0 ;
8895
8896   arg1 = (float)jarg1;
8897   {
8898     try {
8899       result = (Dali::Radian *)new Dali::Radian(arg1);
8900     } catch (std::out_of_range& e) {
8901       {
8902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8903       };
8904     } catch (std::exception& e) {
8905       {
8906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8907       };
8908     } catch (...) {
8909       {
8910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8911       };
8912     }
8913   }
8914   jresult = (void *)result;
8915   return jresult;
8916 }
8917
8918
8919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8920   void * jresult ;
8921   Dali::Degree arg1 ;
8922   Dali::Degree *argp1 ;
8923   Dali::Radian *result = 0 ;
8924
8925   argp1 = (Dali::Degree *)jarg1;
8926   if (!argp1) {
8927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8928     return 0;
8929   }
8930   arg1 = *argp1;
8931   {
8932     try {
8933       result = (Dali::Radian *)new Dali::Radian(arg1);
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (...) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8945       };
8946     }
8947   }
8948   jresult = (void *)result;
8949   return jresult;
8950 }
8951
8952
8953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8954   void * jresult ;
8955   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8956   float arg2 ;
8957   Dali::Radian *result = 0 ;
8958
8959   arg1 = (Dali::Radian *)jarg1;
8960   arg2 = (float)jarg2;
8961   {
8962     try {
8963       result = (Dali::Radian *) &(arg1)->operator =(arg2);
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_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8984   void * jresult ;
8985   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8986   Dali::Degree arg2 ;
8987   Dali::Degree *argp2 ;
8988   Dali::Radian *result = 0 ;
8989
8990   arg1 = (Dali::Radian *)jarg1;
8991   argp2 = (Dali::Degree *)jarg2;
8992   if (!argp2) {
8993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8994     return 0;
8995   }
8996   arg2 = *argp2;
8997   {
8998     try {
8999       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9000     } catch (std::out_of_range& e) {
9001       {
9002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (std::exception& e) {
9005       {
9006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9007       };
9008     } catch (...) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9011       };
9012     }
9013   }
9014   jresult = (void *)result;
9015   return jresult;
9016 }
9017
9018
9019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9020   float jresult ;
9021   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9022   float result;
9023
9024   arg1 = (Dali::Radian *)jarg1;
9025   {
9026     try {
9027       result = (float)((Dali::Radian const *)arg1)->operator float();
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 = result;
9043   return jresult;
9044 }
9045
9046
9047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9048   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9049   float arg2 ;
9050
9051   arg1 = (Dali::Radian *)jarg1;
9052   arg2 = (float)jarg2;
9053   if (arg1) (arg1)->radian = arg2;
9054 }
9055
9056
9057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9058   float jresult ;
9059   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9060   float result;
9061
9062   arg1 = (Dali::Radian *)jarg1;
9063   result = (float) ((arg1)->radian);
9064   jresult = result;
9065   return jresult;
9066 }
9067
9068
9069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9070   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9071
9072   arg1 = (Dali::Radian *)jarg1;
9073   {
9074     try {
9075       delete arg1;
9076     } catch (std::out_of_range& e) {
9077       {
9078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9079       };
9080     } catch (std::exception& e) {
9081       {
9082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9083       };
9084     } catch (...) {
9085       {
9086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9087       };
9088     }
9089   }
9090 }
9091
9092
9093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9094   unsigned int jresult ;
9095   Dali::Radian arg1 ;
9096   Dali::Radian arg2 ;
9097   Dali::Radian *argp1 ;
9098   Dali::Radian *argp2 ;
9099   bool result;
9100
9101   argp1 = (Dali::Radian *)jarg1;
9102   if (!argp1) {
9103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9104     return 0;
9105   }
9106   arg1 = *argp1;
9107   argp2 = (Dali::Radian *)jarg2;
9108   if (!argp2) {
9109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9110     return 0;
9111   }
9112   arg2 = *argp2;
9113   {
9114     try {
9115       result = (bool)Dali::operator ==(arg1,arg2);
9116     } catch (std::out_of_range& e) {
9117       {
9118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9119       };
9120     } catch (std::exception& e) {
9121       {
9122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9123       };
9124     } catch (...) {
9125       {
9126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9127       };
9128     }
9129   }
9130   jresult = result;
9131   return jresult;
9132 }
9133
9134
9135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9136   unsigned int jresult ;
9137   Dali::Radian arg1 ;
9138   Dali::Radian arg2 ;
9139   Dali::Radian *argp1 ;
9140   Dali::Radian *argp2 ;
9141   bool result;
9142
9143   argp1 = (Dali::Radian *)jarg1;
9144   if (!argp1) {
9145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9146     return 0;
9147   }
9148   arg1 = *argp1;
9149   argp2 = (Dali::Radian *)jarg2;
9150   if (!argp2) {
9151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9152     return 0;
9153   }
9154   arg2 = *argp2;
9155   {
9156     try {
9157       result = (bool)Dali::operator !=(arg1,arg2);
9158     } catch (std::out_of_range& e) {
9159       {
9160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9161       };
9162     } catch (std::exception& e) {
9163       {
9164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9165       };
9166     } catch (...) {
9167       {
9168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9169       };
9170     }
9171   }
9172   jresult = result;
9173   return jresult;
9174 }
9175
9176
9177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9178   unsigned int jresult ;
9179   Dali::Radian arg1 ;
9180   Dali::Degree arg2 ;
9181   Dali::Radian *argp1 ;
9182   Dali::Degree *argp2 ;
9183   bool result;
9184
9185   argp1 = (Dali::Radian *)jarg1;
9186   if (!argp1) {
9187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9188     return 0;
9189   }
9190   arg1 = *argp1;
9191   argp2 = (Dali::Degree *)jarg2;
9192   if (!argp2) {
9193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9194     return 0;
9195   }
9196   arg2 = *argp2;
9197   {
9198     try {
9199       result = (bool)Dali::operator ==(arg1,arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9207       };
9208     } catch (...) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9211       };
9212     }
9213   }
9214   jresult = result;
9215   return jresult;
9216 }
9217
9218
9219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9220   unsigned int jresult ;
9221   Dali::Radian arg1 ;
9222   Dali::Degree arg2 ;
9223   Dali::Radian *argp1 ;
9224   Dali::Degree *argp2 ;
9225   bool result;
9226
9227   argp1 = (Dali::Radian *)jarg1;
9228   if (!argp1) {
9229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9230     return 0;
9231   }
9232   arg1 = *argp1;
9233   argp2 = (Dali::Degree *)jarg2;
9234   if (!argp2) {
9235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9236     return 0;
9237   }
9238   arg2 = *argp2;
9239   {
9240     try {
9241       result = (bool)Dali::operator !=(arg1,arg2);
9242     } catch (std::out_of_range& e) {
9243       {
9244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9245       };
9246     } catch (std::exception& e) {
9247       {
9248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (...) {
9251       {
9252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9253       };
9254     }
9255   }
9256   jresult = result;
9257   return jresult;
9258 }
9259
9260
9261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9262   unsigned int jresult ;
9263   Dali::Degree arg1 ;
9264   Dali::Radian arg2 ;
9265   Dali::Degree *argp1 ;
9266   Dali::Radian *argp2 ;
9267   bool result;
9268
9269   argp1 = (Dali::Degree *)jarg1;
9270   if (!argp1) {
9271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9272     return 0;
9273   }
9274   arg1 = *argp1;
9275   argp2 = (Dali::Radian *)jarg2;
9276   if (!argp2) {
9277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9278     return 0;
9279   }
9280   arg2 = *argp2;
9281   {
9282     try {
9283       result = (bool)Dali::operator ==(arg1,arg2);
9284     } catch (std::out_of_range& e) {
9285       {
9286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9287       };
9288     } catch (std::exception& e) {
9289       {
9290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (...) {
9293       {
9294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9295       };
9296     }
9297   }
9298   jresult = result;
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9304   unsigned int jresult ;
9305   Dali::Degree arg1 ;
9306   Dali::Radian arg2 ;
9307   Dali::Degree *argp1 ;
9308   Dali::Radian *argp2 ;
9309   bool result;
9310
9311   argp1 = (Dali::Degree *)jarg1;
9312   if (!argp1) {
9313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9314     return 0;
9315   }
9316   arg1 = *argp1;
9317   argp2 = (Dali::Radian *)jarg2;
9318   if (!argp2) {
9319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9320     return 0;
9321   }
9322   arg2 = *argp2;
9323   {
9324     try {
9325       result = (bool)Dali::operator !=(arg1,arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (...) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9337       };
9338     }
9339   }
9340   jresult = result;
9341   return jresult;
9342 }
9343
9344
9345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9346   unsigned int jresult ;
9347   Dali::Radian arg1 ;
9348   Dali::Radian arg2 ;
9349   Dali::Radian *argp1 ;
9350   Dali::Radian *argp2 ;
9351   bool result;
9352
9353   argp1 = (Dali::Radian *)jarg1;
9354   if (!argp1) {
9355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9356     return 0;
9357   }
9358   arg1 = *argp1;
9359   argp2 = (Dali::Radian *)jarg2;
9360   if (!argp2) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9362     return 0;
9363   }
9364   arg2 = *argp2;
9365   {
9366     try {
9367       result = (bool)Dali::operator >(arg1,arg2);
9368     } catch (std::out_of_range& e) {
9369       {
9370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (std::exception& e) {
9373       {
9374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (...) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9379       };
9380     }
9381   }
9382   jresult = result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9388   unsigned int jresult ;
9389   Dali::Radian arg1 ;
9390   Dali::Degree arg2 ;
9391   Dali::Radian *argp1 ;
9392   Dali::Degree *argp2 ;
9393   bool result;
9394
9395   argp1 = (Dali::Radian *)jarg1;
9396   if (!argp1) {
9397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9398     return 0;
9399   }
9400   arg1 = *argp1;
9401   argp2 = (Dali::Degree *)jarg2;
9402   if (!argp2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9404     return 0;
9405   }
9406   arg2 = *argp2;
9407   {
9408     try {
9409       result = (bool)Dali::operator >(arg1,arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (...) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9421       };
9422     }
9423   }
9424   jresult = result;
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9430   unsigned int jresult ;
9431   Dali::Degree arg1 ;
9432   Dali::Radian arg2 ;
9433   Dali::Degree *argp1 ;
9434   Dali::Radian *argp2 ;
9435   bool result;
9436
9437   argp1 = (Dali::Degree *)jarg1;
9438   if (!argp1) {
9439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9440     return 0;
9441   }
9442   arg1 = *argp1;
9443   argp2 = (Dali::Radian *)jarg2;
9444   if (!argp2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9446     return 0;
9447   }
9448   arg2 = *argp2;
9449   {
9450     try {
9451       result = (bool)Dali::operator >(arg1,arg2);
9452     } catch (std::out_of_range& e) {
9453       {
9454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (std::exception& e) {
9457       {
9458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466   jresult = result;
9467   return jresult;
9468 }
9469
9470
9471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9472   unsigned int jresult ;
9473   Dali::Radian arg1 ;
9474   Dali::Radian arg2 ;
9475   Dali::Radian *argp1 ;
9476   Dali::Radian *argp2 ;
9477   bool result;
9478
9479   argp1 = (Dali::Radian *)jarg1;
9480   if (!argp1) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9482     return 0;
9483   }
9484   arg1 = *argp1;
9485   argp2 = (Dali::Radian *)jarg2;
9486   if (!argp2) {
9487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9488     return 0;
9489   }
9490   arg2 = *argp2;
9491   {
9492     try {
9493       result = (bool)Dali::operator <(arg1,arg2);
9494     } catch (std::out_of_range& e) {
9495       {
9496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (std::exception& e) {
9499       {
9500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508   jresult = result;
9509   return jresult;
9510 }
9511
9512
9513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9514   unsigned int jresult ;
9515   Dali::Radian arg1 ;
9516   Dali::Degree arg2 ;
9517   Dali::Radian *argp1 ;
9518   Dali::Degree *argp2 ;
9519   bool result;
9520
9521   argp1 = (Dali::Radian *)jarg1;
9522   if (!argp1) {
9523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9524     return 0;
9525   }
9526   arg1 = *argp1;
9527   argp2 = (Dali::Degree *)jarg2;
9528   if (!argp2) {
9529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9530     return 0;
9531   }
9532   arg2 = *argp2;
9533   {
9534     try {
9535       result = (bool)Dali::operator <(arg1,arg2);
9536     } catch (std::out_of_range& e) {
9537       {
9538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (std::exception& e) {
9541       {
9542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (...) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9547       };
9548     }
9549   }
9550   jresult = result;
9551   return jresult;
9552 }
9553
9554
9555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9556   unsigned int jresult ;
9557   Dali::Degree arg1 ;
9558   Dali::Radian arg2 ;
9559   Dali::Degree *argp1 ;
9560   Dali::Radian *argp2 ;
9561   bool result;
9562
9563   argp1 = (Dali::Degree *)jarg1;
9564   if (!argp1) {
9565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9566     return 0;
9567   }
9568   arg1 = *argp1;
9569   argp2 = (Dali::Radian *)jarg2;
9570   if (!argp2) {
9571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9572     return 0;
9573   }
9574   arg2 = *argp2;
9575   {
9576     try {
9577       result = (bool)Dali::operator <(arg1,arg2);
9578     } catch (std::out_of_range& e) {
9579       {
9580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (std::exception& e) {
9583       {
9584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (...) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9589       };
9590     }
9591   }
9592   jresult = result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9598   void * jresult ;
9599   Dali::Radian arg1 ;
9600   float arg2 ;
9601   Dali::Radian *argp1 ;
9602   Dali::Radian result;
9603
9604   argp1 = (Dali::Radian *)jarg1;
9605   if (!argp1) {
9606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9607     return 0;
9608   }
9609   arg1 = *argp1;
9610   arg2 = (float)jarg2;
9611   {
9612     try {
9613       result = Dali::operator *(arg1,arg2);
9614     } catch (std::out_of_range& e) {
9615       {
9616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9617       };
9618     } catch (std::exception& e) {
9619       {
9620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9621       };
9622     } catch (...) {
9623       {
9624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9625       };
9626     }
9627   }
9628   jresult = new Dali::Radian((const Dali::Radian &)result);
9629   return jresult;
9630 }
9631
9632
9633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9634   void * jresult ;
9635   Dali::Radian arg1 ;
9636   Dali::Radian *argp1 ;
9637   Dali::Radian result;
9638
9639   argp1 = (Dali::Radian *)jarg1;
9640   if (!argp1) {
9641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9642     return 0;
9643   }
9644   arg1 = *argp1;
9645   {
9646     try {
9647       result = Dali::operator -(arg1);
9648     } catch (std::out_of_range& e) {
9649       {
9650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9651       };
9652     } catch (std::exception& e) {
9653       {
9654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9655       };
9656     } catch (...) {
9657       {
9658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9659       };
9660     }
9661   }
9662   jresult = new Dali::Radian((const Dali::Radian &)result);
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9668   void * jresult ;
9669   Dali::Radian arg1 ;
9670   float arg2 ;
9671   float arg3 ;
9672   Dali::Radian *argp1 ;
9673   Dali::Radian result;
9674
9675   argp1 = (Dali::Radian *)jarg1;
9676   if (!argp1) {
9677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9678     return 0;
9679   }
9680   arg1 = *argp1;
9681   arg2 = (float)jarg2;
9682   arg3 = (float)jarg3;
9683   {
9684     try {
9685       result = Dali::Clamp(arg1,arg2,arg3);
9686     } catch (std::out_of_range& e) {
9687       {
9688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9689       };
9690     } catch (std::exception& e) {
9691       {
9692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9693       };
9694     } catch (...) {
9695       {
9696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9697       };
9698     }
9699   }
9700   jresult = new Dali::Radian((const Dali::Radian &)result);
9701   return jresult;
9702 }
9703
9704
9705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9706   void * jresult ;
9707   Dali::Quaternion *result = 0 ;
9708
9709   {
9710     try {
9711       result = (Dali::Quaternion *)new Dali::Quaternion();
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 = (void *)result;
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9732   void * jresult ;
9733   Dali::Radian arg1 ;
9734   Dali::Vector3 *arg2 = 0 ;
9735   Dali::Radian *argp1 ;
9736   Dali::Quaternion *result = 0 ;
9737
9738   argp1 = (Dali::Radian *)jarg1;
9739   if (!argp1) {
9740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9741     return 0;
9742   }
9743   arg1 = *argp1;
9744   arg2 = (Dali::Vector3 *)jarg2;
9745   if (!arg2) {
9746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9747     return 0;
9748   }
9749   {
9750     try {
9751       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9752     } catch (std::out_of_range& e) {
9753       {
9754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9755       };
9756     } catch (std::exception& e) {
9757       {
9758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9759       };
9760     } catch (...) {
9761       {
9762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9763       };
9764     }
9765   }
9766   jresult = (void *)result;
9767   return jresult;
9768 }
9769
9770
9771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9772   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9773
9774   arg1 = (Dali::Quaternion *)jarg1;
9775   {
9776     try {
9777       delete arg1;
9778     } catch (std::out_of_range& e) {
9779       {
9780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9781       };
9782     } catch (std::exception& e) {
9783       {
9784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9785       };
9786     } catch (...) {
9787       {
9788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9789       };
9790     }
9791   }
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9796   void * jresult ;
9797   Dali::Quaternion *result = 0 ;
9798
9799   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9800   jresult = (void *)result;
9801   return jresult;
9802 }
9803
9804
9805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9806   unsigned int jresult ;
9807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9808   bool result;
9809
9810   arg1 = (Dali::Quaternion *)jarg1;
9811   {
9812     try {
9813       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9814     } catch (std::out_of_range& e) {
9815       {
9816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9817       };
9818     } catch (std::exception& e) {
9819       {
9820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9821       };
9822     } catch (...) {
9823       {
9824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9825       };
9826     }
9827   }
9828   jresult = result;
9829   return jresult;
9830 }
9831
9832
9833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9834   unsigned int jresult ;
9835   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9836   Dali::Vector3 *arg2 = 0 ;
9837   Dali::Radian *arg3 = 0 ;
9838   bool result;
9839
9840   arg1 = (Dali::Quaternion *)jarg1;
9841   arg2 = (Dali::Vector3 *)jarg2;
9842   if (!arg2) {
9843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9844     return 0;
9845   }
9846   arg3 = (Dali::Radian *)jarg3;
9847   if (!arg3) {
9848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9849     return 0;
9850   }
9851   {
9852     try {
9853       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9854     } catch (std::out_of_range& e) {
9855       {
9856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9857       };
9858     } catch (std::exception& e) {
9859       {
9860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9861       };
9862     } catch (...) {
9863       {
9864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9865       };
9866     }
9867   }
9868   jresult = result;
9869   return jresult;
9870 }
9871
9872
9873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9874   void * jresult ;
9875   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9876   Dali::Quaternion *arg2 = 0 ;
9877   Dali::Quaternion result;
9878
9879   arg1 = (Dali::Quaternion *)jarg1;
9880   arg2 = (Dali::Quaternion *)jarg2;
9881   if (!arg2) {
9882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9883     return 0;
9884   }
9885   {
9886     try {
9887       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9888     } catch (std::out_of_range& e) {
9889       {
9890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9891       };
9892     } catch (std::exception& e) {
9893       {
9894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9895       };
9896     } catch (...) {
9897       {
9898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9899       };
9900     }
9901   }
9902   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9903   return jresult;
9904 }
9905
9906
9907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9908   void * jresult ;
9909   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9910   Dali::Quaternion *arg2 = 0 ;
9911   Dali::Quaternion result;
9912
9913   arg1 = (Dali::Quaternion *)jarg1;
9914   arg2 = (Dali::Quaternion *)jarg2;
9915   if (!arg2) {
9916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9917     return 0;
9918   }
9919   {
9920     try {
9921       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9922     } catch (std::out_of_range& e) {
9923       {
9924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (std::exception& e) {
9927       {
9928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9929       };
9930     } catch (...) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9933       };
9934     }
9935   }
9936   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9937   return jresult;
9938 }
9939
9940
9941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9942   void * jresult ;
9943   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9944   Dali::Quaternion *arg2 = 0 ;
9945   Dali::Quaternion result;
9946
9947   arg1 = (Dali::Quaternion *)jarg1;
9948   arg2 = (Dali::Quaternion *)jarg2;
9949   if (!arg2) {
9950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9951     return 0;
9952   }
9953   {
9954     try {
9955       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9956     } catch (std::out_of_range& e) {
9957       {
9958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9959       };
9960     } catch (std::exception& e) {
9961       {
9962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9963       };
9964     } catch (...) {
9965       {
9966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9967       };
9968     }
9969   }
9970   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9971   return jresult;
9972 }
9973
9974
9975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9976   void * jresult ;
9977   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9978   Dali::Vector3 *arg2 = 0 ;
9979   Dali::Vector3 result;
9980
9981   arg1 = (Dali::Quaternion *)jarg1;
9982   arg2 = (Dali::Vector3 *)jarg2;
9983   if (!arg2) {
9984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9985     return 0;
9986   }
9987   {
9988     try {
9989       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9990     } catch (std::out_of_range& e) {
9991       {
9992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (std::exception& e) {
9995       {
9996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9997       };
9998     } catch (...) {
9999       {
10000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10001       };
10002     }
10003   }
10004   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10005   return jresult;
10006 }
10007
10008
10009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10010   void * jresult ;
10011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10012   Dali::Quaternion *arg2 = 0 ;
10013   Dali::Quaternion result;
10014
10015   arg1 = (Dali::Quaternion *)jarg1;
10016   arg2 = (Dali::Quaternion *)jarg2;
10017   if (!arg2) {
10018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10019     return 0;
10020   }
10021   {
10022     try {
10023       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10024     } catch (std::out_of_range& e) {
10025       {
10026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10027       };
10028     } catch (std::exception& e) {
10029       {
10030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10031       };
10032     } catch (...) {
10033       {
10034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10035       };
10036     }
10037   }
10038   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10039   return jresult;
10040 }
10041
10042
10043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10044   void * jresult ;
10045   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10046   float arg2 ;
10047   Dali::Quaternion result;
10048
10049   arg1 = (Dali::Quaternion *)jarg1;
10050   arg2 = (float)jarg2;
10051   {
10052     try {
10053       result = ((Dali::Quaternion const *)arg1)->operator *(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::Quaternion((const Dali::Quaternion &)result);
10069   return jresult;
10070 }
10071
10072
10073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10074   void * jresult ;
10075   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10076   float arg2 ;
10077   Dali::Quaternion result;
10078
10079   arg1 = (Dali::Quaternion *)jarg1;
10080   arg2 = (float)jarg2;
10081   {
10082     try {
10083       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10084     } catch (std::out_of_range& e) {
10085       {
10086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10087       };
10088     } catch (std::exception& e) {
10089       {
10090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (...) {
10093       {
10094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10095       };
10096     }
10097   }
10098   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10099   return jresult;
10100 }
10101
10102
10103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10104   void * jresult ;
10105   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10106   Dali::Quaternion result;
10107
10108   arg1 = (Dali::Quaternion *)jarg1;
10109   {
10110     try {
10111       result = ((Dali::Quaternion const *)arg1)->operator -();
10112     } catch (std::out_of_range& e) {
10113       {
10114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10115       };
10116     } catch (std::exception& e) {
10117       {
10118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10119       };
10120     } catch (...) {
10121       {
10122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10123       };
10124     }
10125   }
10126   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10127   return jresult;
10128 }
10129
10130
10131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10132   void * jresult ;
10133   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10134   Dali::Quaternion *arg2 = 0 ;
10135   Dali::Quaternion *result = 0 ;
10136
10137   arg1 = (Dali::Quaternion *)jarg1;
10138   arg2 = (Dali::Quaternion *)jarg2;
10139   if (!arg2) {
10140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10141     return 0;
10142   }
10143   {
10144     try {
10145       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10146     } catch (std::out_of_range& e) {
10147       {
10148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10149       };
10150     } catch (std::exception& e) {
10151       {
10152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10153       };
10154     } catch (...) {
10155       {
10156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10157       };
10158     }
10159   }
10160   jresult = (void *)result;
10161   return jresult;
10162 }
10163
10164
10165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10166   void * jresult ;
10167   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10168   Dali::Quaternion *arg2 = 0 ;
10169   Dali::Quaternion *result = 0 ;
10170
10171   arg1 = (Dali::Quaternion *)jarg1;
10172   arg2 = (Dali::Quaternion *)jarg2;
10173   if (!arg2) {
10174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10175     return 0;
10176   }
10177   {
10178     try {
10179       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10180     } catch (std::out_of_range& e) {
10181       {
10182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10183       };
10184     } catch (std::exception& e) {
10185       {
10186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10187       };
10188     } catch (...) {
10189       {
10190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10191       };
10192     }
10193   }
10194   jresult = (void *)result;
10195   return jresult;
10196 }
10197
10198
10199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10200   void * jresult ;
10201   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10202   Dali::Quaternion *arg2 = 0 ;
10203   Dali::Quaternion *result = 0 ;
10204
10205   arg1 = (Dali::Quaternion *)jarg1;
10206   arg2 = (Dali::Quaternion *)jarg2;
10207   if (!arg2) {
10208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10209     return 0;
10210   }
10211   {
10212     try {
10213       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10214     } catch (std::out_of_range& e) {
10215       {
10216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10217       };
10218     } catch (std::exception& e) {
10219       {
10220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10221       };
10222     } catch (...) {
10223       {
10224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10225       };
10226     }
10227   }
10228   jresult = (void *)result;
10229   return jresult;
10230 }
10231
10232
10233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10234   void * jresult ;
10235   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10236   float arg2 ;
10237   Dali::Quaternion *result = 0 ;
10238
10239   arg1 = (Dali::Quaternion *)jarg1;
10240   arg2 = (float)jarg2;
10241   {
10242     try {
10243       result = (Dali::Quaternion *) &(arg1)->operator *=(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_DivideAssign(void * jarg1, float jarg2) {
10264   void * jresult ;
10265   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10266   float arg2 ;
10267   Dali::Quaternion *result = 0 ;
10268
10269   arg1 = (Dali::Quaternion *)jarg1;
10270   arg2 = (float)jarg2;
10271   {
10272     try {
10273       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10274     } catch (std::out_of_range& e) {
10275       {
10276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10277       };
10278     } catch (std::exception& e) {
10279       {
10280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (...) {
10283       {
10284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10285       };
10286     }
10287   }
10288   jresult = (void *)result;
10289   return jresult;
10290 }
10291
10292
10293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10294   unsigned int jresult ;
10295   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10296   Dali::Quaternion *arg2 = 0 ;
10297   bool result;
10298
10299   arg1 = (Dali::Quaternion *)jarg1;
10300   arg2 = (Dali::Quaternion *)jarg2;
10301   if (!arg2) {
10302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10303     return 0;
10304   }
10305   {
10306     try {
10307       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*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 = result;
10323   return jresult;
10324 }
10325
10326
10327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10328   unsigned int jresult ;
10329   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10330   Dali::Quaternion *arg2 = 0 ;
10331   bool result;
10332
10333   arg1 = (Dali::Quaternion *)jarg1;
10334   arg2 = (Dali::Quaternion *)jarg2;
10335   if (!arg2) {
10336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10337     return 0;
10338   }
10339   {
10340     try {
10341       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10342     } catch (std::out_of_range& e) {
10343       {
10344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10345       };
10346     } catch (std::exception& e) {
10347       {
10348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10349       };
10350     } catch (...) {
10351       {
10352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10353       };
10354     }
10355   }
10356   jresult = result;
10357   return jresult;
10358 }
10359
10360
10361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10362   float jresult ;
10363   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10364   float result;
10365
10366   arg1 = (Dali::Quaternion *)jarg1;
10367   {
10368     try {
10369       result = (float)((Dali::Quaternion const *)arg1)->Length();
10370     } catch (std::out_of_range& e) {
10371       {
10372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10373       };
10374     } catch (std::exception& e) {
10375       {
10376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (...) {
10379       {
10380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10381       };
10382     }
10383   }
10384   jresult = result;
10385   return jresult;
10386 }
10387
10388
10389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10390   float jresult ;
10391   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10392   float result;
10393
10394   arg1 = (Dali::Quaternion *)jarg1;
10395   {
10396     try {
10397       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10398     } catch (std::out_of_range& e) {
10399       {
10400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10401       };
10402     } catch (std::exception& e) {
10403       {
10404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10405       };
10406     } catch (...) {
10407       {
10408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10409       };
10410     }
10411   }
10412   jresult = result;
10413   return jresult;
10414 }
10415
10416
10417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10418   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10419
10420   arg1 = (Dali::Quaternion *)jarg1;
10421   {
10422     try {
10423       (arg1)->Normalize();
10424     } catch (std::out_of_range& e) {
10425       {
10426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10427       };
10428     } catch (std::exception& e) {
10429       {
10430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10435       };
10436     }
10437   }
10438 }
10439
10440
10441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10442   void * jresult ;
10443   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10444   Dali::Quaternion result;
10445
10446   arg1 = (Dali::Quaternion *)jarg1;
10447   {
10448     try {
10449       result = ((Dali::Quaternion const *)arg1)->Normalized();
10450     } catch (std::out_of_range& e) {
10451       {
10452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10453       };
10454     } catch (std::exception& e) {
10455       {
10456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (...) {
10459       {
10460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10461       };
10462     }
10463   }
10464   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10465   return jresult;
10466 }
10467
10468
10469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10470   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10471
10472   arg1 = (Dali::Quaternion *)jarg1;
10473   {
10474     try {
10475       (arg1)->Conjugate();
10476     } catch (std::out_of_range& e) {
10477       {
10478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10479       };
10480     } catch (std::exception& e) {
10481       {
10482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10483       };
10484     } catch (...) {
10485       {
10486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10487       };
10488     }
10489   }
10490 }
10491
10492
10493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10494   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10495
10496   arg1 = (Dali::Quaternion *)jarg1;
10497   {
10498     try {
10499       (arg1)->Invert();
10500     } catch (std::out_of_range& e) {
10501       {
10502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10503       };
10504     } catch (std::exception& e) {
10505       {
10506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10507       };
10508     } catch (...) {
10509       {
10510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10511       };
10512     }
10513   }
10514 }
10515
10516
10517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10518   void * jresult ;
10519   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10520   Dali::Quaternion result;
10521
10522   arg1 = (Dali::Quaternion *)jarg1;
10523   {
10524     try {
10525       result = ((Dali::Quaternion const *)arg1)->Log();
10526     } catch (std::out_of_range& e) {
10527       {
10528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10529       };
10530     } catch (std::exception& e) {
10531       {
10532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10533       };
10534     } catch (...) {
10535       {
10536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10537       };
10538     }
10539   }
10540   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10541   return jresult;
10542 }
10543
10544
10545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10546   void * jresult ;
10547   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10548   Dali::Quaternion result;
10549
10550   arg1 = (Dali::Quaternion *)jarg1;
10551   {
10552     try {
10553       result = ((Dali::Quaternion const *)arg1)->Exp();
10554     } catch (std::out_of_range& e) {
10555       {
10556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10557       };
10558     } catch (std::exception& e) {
10559       {
10560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10561       };
10562     } catch (...) {
10563       {
10564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10565       };
10566     }
10567   }
10568   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10569   return jresult;
10570 }
10571
10572
10573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10574   float jresult ;
10575   Dali::Quaternion *arg1 = 0 ;
10576   Dali::Quaternion *arg2 = 0 ;
10577   float result;
10578
10579   arg1 = (Dali::Quaternion *)jarg1;
10580   if (!arg1) {
10581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10582     return 0;
10583   }
10584   arg2 = (Dali::Quaternion *)jarg2;
10585   if (!arg2) {
10586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10587     return 0;
10588   }
10589   {
10590     try {
10591       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10592     } catch (std::out_of_range& e) {
10593       {
10594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10595       };
10596     } catch (std::exception& e) {
10597       {
10598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10599       };
10600     } catch (...) {
10601       {
10602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10603       };
10604     }
10605   }
10606   jresult = result;
10607   return jresult;
10608 }
10609
10610
10611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10612   void * jresult ;
10613   Dali::Quaternion *arg1 = 0 ;
10614   Dali::Quaternion *arg2 = 0 ;
10615   float arg3 ;
10616   Dali::Quaternion result;
10617
10618   arg1 = (Dali::Quaternion *)jarg1;
10619   if (!arg1) {
10620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10621     return 0;
10622   }
10623   arg2 = (Dali::Quaternion *)jarg2;
10624   if (!arg2) {
10625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10626     return 0;
10627   }
10628   arg3 = (float)jarg3;
10629   {
10630     try {
10631       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10632     } catch (std::out_of_range& e) {
10633       {
10634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10635       };
10636     } catch (std::exception& e) {
10637       {
10638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10639       };
10640     } catch (...) {
10641       {
10642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10643       };
10644     }
10645   }
10646   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10647   return jresult;
10648 }
10649
10650
10651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10652   void * jresult ;
10653   Dali::Quaternion *arg1 = 0 ;
10654   Dali::Quaternion *arg2 = 0 ;
10655   float arg3 ;
10656   Dali::Quaternion result;
10657
10658   arg1 = (Dali::Quaternion *)jarg1;
10659   if (!arg1) {
10660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10661     return 0;
10662   }
10663   arg2 = (Dali::Quaternion *)jarg2;
10664   if (!arg2) {
10665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10666     return 0;
10667   }
10668   arg3 = (float)jarg3;
10669   {
10670     try {
10671       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10672     } catch (std::out_of_range& e) {
10673       {
10674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10675       };
10676     } catch (std::exception& e) {
10677       {
10678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10679       };
10680     } catch (...) {
10681       {
10682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10683       };
10684     }
10685   }
10686   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10687   return jresult;
10688 }
10689
10690
10691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10692   void * jresult ;
10693   Dali::Quaternion *arg1 = 0 ;
10694   Dali::Quaternion *arg2 = 0 ;
10695   float arg3 ;
10696   Dali::Quaternion result;
10697
10698   arg1 = (Dali::Quaternion *)jarg1;
10699   if (!arg1) {
10700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10701     return 0;
10702   }
10703   arg2 = (Dali::Quaternion *)jarg2;
10704   if (!arg2) {
10705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10706     return 0;
10707   }
10708   arg3 = (float)jarg3;
10709   {
10710     try {
10711       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10712     } catch (std::out_of_range& e) {
10713       {
10714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10715       };
10716     } catch (std::exception& e) {
10717       {
10718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10719       };
10720     } catch (...) {
10721       {
10722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10723       };
10724     }
10725   }
10726   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10727   return jresult;
10728 }
10729
10730
10731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10732   void * jresult ;
10733   Dali::Quaternion *arg1 = 0 ;
10734   Dali::Quaternion *arg2 = 0 ;
10735   Dali::Quaternion *arg3 = 0 ;
10736   Dali::Quaternion *arg4 = 0 ;
10737   float arg5 ;
10738   Dali::Quaternion result;
10739
10740   arg1 = (Dali::Quaternion *)jarg1;
10741   if (!arg1) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10743     return 0;
10744   }
10745   arg2 = (Dali::Quaternion *)jarg2;
10746   if (!arg2) {
10747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10748     return 0;
10749   }
10750   arg3 = (Dali::Quaternion *)jarg3;
10751   if (!arg3) {
10752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10753     return 0;
10754   }
10755   arg4 = (Dali::Quaternion *)jarg4;
10756   if (!arg4) {
10757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10758     return 0;
10759   }
10760   arg5 = (float)jarg5;
10761   {
10762     try {
10763       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10764     } catch (std::out_of_range& e) {
10765       {
10766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10767       };
10768     } catch (std::exception& e) {
10769       {
10770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10771       };
10772     } catch (...) {
10773       {
10774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10775       };
10776     }
10777   }
10778   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10779   return jresult;
10780 }
10781
10782
10783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10784   float jresult ;
10785   Dali::Quaternion *arg1 = 0 ;
10786   Dali::Quaternion *arg2 = 0 ;
10787   float result;
10788
10789   arg1 = (Dali::Quaternion *)jarg1;
10790   if (!arg1) {
10791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10792     return 0;
10793   }
10794   arg2 = (Dali::Quaternion *)jarg2;
10795   if (!arg2) {
10796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10797     return 0;
10798   }
10799   {
10800     try {
10801       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10802     } catch (std::out_of_range& e) {
10803       {
10804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10805       };
10806     } catch (std::exception& e) {
10807       {
10808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10809       };
10810     } catch (...) {
10811       {
10812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10813       };
10814     }
10815   }
10816   jresult = result;
10817   return jresult;
10818 }
10819
10820
10821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10822   void * jresult ;
10823   Dali::Matrix *result = 0 ;
10824
10825   {
10826     try {
10827       result = (Dali::Matrix *)new Dali::Matrix();
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 = (void *)result;
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10848   void * jresult ;
10849   bool arg1 ;
10850   Dali::Matrix *result = 0 ;
10851
10852   arg1 = jarg1 ? true : false;
10853   {
10854     try {
10855       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10856     } catch (std::out_of_range& e) {
10857       {
10858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (std::exception& e) {
10861       {
10862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10863       };
10864     } catch (...) {
10865       {
10866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10867       };
10868     }
10869   }
10870   jresult = (void *)result;
10871   return jresult;
10872 }
10873
10874
10875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10876   void * jresult ;
10877   float *arg1 = (float *) 0 ;
10878   Dali::Matrix *result = 0 ;
10879
10880   arg1 = jarg1;
10881   {
10882     try {
10883       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10884     } catch (std::out_of_range& e) {
10885       {
10886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10887       };
10888     } catch (std::exception& e) {
10889       {
10890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10891       };
10892     } catch (...) {
10893       {
10894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10895       };
10896     }
10897   }
10898   jresult = (void *)result;
10899
10900
10901   return jresult;
10902 }
10903
10904
10905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10906   void * jresult ;
10907   Dali::Quaternion *arg1 = 0 ;
10908   Dali::Matrix *result = 0 ;
10909
10910   arg1 = (Dali::Quaternion *)jarg1;
10911   if (!arg1) {
10912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10913     return 0;
10914   }
10915   {
10916     try {
10917       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10918     } catch (std::out_of_range& e) {
10919       {
10920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10921       };
10922     } catch (std::exception& e) {
10923       {
10924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10925       };
10926     } catch (...) {
10927       {
10928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10929       };
10930     }
10931   }
10932   jresult = (void *)result;
10933   return jresult;
10934 }
10935
10936
10937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10938   void * jresult ;
10939   Dali::Matrix *arg1 = 0 ;
10940   Dali::Matrix *result = 0 ;
10941
10942   arg1 = (Dali::Matrix *)jarg1;
10943   if (!arg1) {
10944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10945     return 0;
10946   }
10947   {
10948     try {
10949       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10950     } catch (std::out_of_range& e) {
10951       {
10952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10953       };
10954     } catch (std::exception& e) {
10955       {
10956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10961       };
10962     }
10963   }
10964   jresult = (void *)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10970   void * jresult ;
10971   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10972   Dali::Matrix *arg2 = 0 ;
10973   Dali::Matrix *result = 0 ;
10974
10975   arg1 = (Dali::Matrix *)jarg1;
10976   arg2 = (Dali::Matrix *)jarg2;
10977   if (!arg2) {
10978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10979     return 0;
10980   }
10981   {
10982     try {
10983       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10984     } catch (std::out_of_range& e) {
10985       {
10986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10987       };
10988     } catch (std::exception& e) {
10989       {
10990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10991       };
10992     } catch (...) {
10993       {
10994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10995       };
10996     }
10997   }
10998   jresult = (void *)result;
10999   return jresult;
11000 }
11001
11002
11003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11004   void * jresult ;
11005   Dali::Matrix *result = 0 ;
11006
11007   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11008   jresult = (void *)result;
11009   return jresult;
11010 }
11011
11012
11013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11014   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11015
11016   arg1 = (Dali::Matrix *)jarg1;
11017   {
11018     try {
11019       (arg1)->SetIdentity();
11020     } catch (std::out_of_range& e) {
11021       {
11022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11023       };
11024     } catch (std::exception& e) {
11025       {
11026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11027       };
11028     } catch (...) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11031       };
11032     }
11033   }
11034 }
11035
11036
11037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11038   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11039   Dali::Vector3 *arg2 = 0 ;
11040
11041   arg1 = (Dali::Matrix *)jarg1;
11042   arg2 = (Dali::Vector3 *)jarg2;
11043   if (!arg2) {
11044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11045     return ;
11046   }
11047   {
11048     try {
11049       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11050     } catch (std::out_of_range& e) {
11051       {
11052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11053       };
11054     } catch (std::exception& e) {
11055       {
11056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11057       };
11058     } catch (...) {
11059       {
11060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11061       };
11062     }
11063   }
11064 }
11065
11066
11067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11068   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11069   Dali::Matrix *arg2 = 0 ;
11070
11071   arg1 = (Dali::Matrix *)jarg1;
11072   arg2 = (Dali::Matrix *)jarg2;
11073   if (!arg2) {
11074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11075     return ;
11076   }
11077   {
11078     try {
11079       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11080     } catch (std::out_of_range& e) {
11081       {
11082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11083       };
11084     } catch (std::exception& e) {
11085       {
11086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11087       };
11088     } catch (...) {
11089       {
11090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11091       };
11092     }
11093   }
11094 }
11095
11096
11097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11098   unsigned int jresult ;
11099   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11100   bool result;
11101
11102   arg1 = (Dali::Matrix *)jarg1;
11103   {
11104     try {
11105       result = (bool)(arg1)->Invert();
11106     } catch (std::out_of_range& e) {
11107       {
11108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (std::exception& e) {
11111       {
11112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120   jresult = result;
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11126   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11127
11128   arg1 = (Dali::Matrix *)jarg1;
11129   {
11130     try {
11131       (arg1)->Transpose();
11132     } catch (std::out_of_range& e) {
11133       {
11134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11135       };
11136     } catch (std::exception& e) {
11137       {
11138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11139       };
11140     } catch (...) {
11141       {
11142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11143       };
11144     }
11145   }
11146 }
11147
11148
11149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11150   void * jresult ;
11151   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11152   Dali::Vector3 result;
11153
11154   arg1 = (Dali::Matrix *)jarg1;
11155   {
11156     try {
11157       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11158     } catch (std::out_of_range& e) {
11159       {
11160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11161       };
11162     } catch (std::exception& e) {
11163       {
11164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11165       };
11166     } catch (...) {
11167       {
11168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11169       };
11170     }
11171   }
11172   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11173   return jresult;
11174 }
11175
11176
11177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11178   void * jresult ;
11179   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11180   Dali::Vector3 result;
11181
11182   arg1 = (Dali::Matrix *)jarg1;
11183   {
11184     try {
11185       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11186     } catch (std::out_of_range& e) {
11187       {
11188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (std::exception& e) {
11191       {
11192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11193       };
11194     } catch (...) {
11195       {
11196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11197       };
11198     }
11199   }
11200   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11201   return jresult;
11202 }
11203
11204
11205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11206   void * jresult ;
11207   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11208   Dali::Vector3 result;
11209
11210   arg1 = (Dali::Matrix *)jarg1;
11211   {
11212     try {
11213       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11214     } catch (std::out_of_range& e) {
11215       {
11216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11217       };
11218     } catch (std::exception& e) {
11219       {
11220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11221       };
11222     } catch (...) {
11223       {
11224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11225       };
11226     }
11227   }
11228   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11229   return jresult;
11230 }
11231
11232
11233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11234   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11235   Dali::Vector3 *arg2 = 0 ;
11236
11237   arg1 = (Dali::Matrix *)jarg1;
11238   arg2 = (Dali::Vector3 *)jarg2;
11239   if (!arg2) {
11240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11241     return ;
11242   }
11243   {
11244     try {
11245       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11246     } catch (std::out_of_range& e) {
11247       {
11248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11249       };
11250     } catch (std::exception& e) {
11251       {
11252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11253       };
11254     } catch (...) {
11255       {
11256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11257       };
11258     }
11259   }
11260 }
11261
11262
11263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11264   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11265   Dali::Vector3 *arg2 = 0 ;
11266
11267   arg1 = (Dali::Matrix *)jarg1;
11268   arg2 = (Dali::Vector3 *)jarg2;
11269   if (!arg2) {
11270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11271     return ;
11272   }
11273   {
11274     try {
11275       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11276     } catch (std::out_of_range& e) {
11277       {
11278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11279       };
11280     } catch (std::exception& e) {
11281       {
11282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11283       };
11284     } catch (...) {
11285       {
11286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11287       };
11288     }
11289   }
11290 }
11291
11292
11293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11294   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11295   Dali::Vector3 *arg2 = 0 ;
11296
11297   arg1 = (Dali::Matrix *)jarg1;
11298   arg2 = (Dali::Vector3 *)jarg2;
11299   if (!arg2) {
11300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11301     return ;
11302   }
11303   {
11304     try {
11305       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11306     } catch (std::out_of_range& e) {
11307       {
11308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11309       };
11310     } catch (std::exception& e) {
11311       {
11312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11313       };
11314     } catch (...) {
11315       {
11316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11317       };
11318     }
11319   }
11320 }
11321
11322
11323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11324   void * jresult ;
11325   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11326   Dali::Vector4 *result = 0 ;
11327
11328   arg1 = (Dali::Matrix *)jarg1;
11329   {
11330     try {
11331       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11332     } catch (std::out_of_range& e) {
11333       {
11334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11335       };
11336     } catch (std::exception& e) {
11337       {
11338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11339       };
11340     } catch (...) {
11341       {
11342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11343       };
11344     }
11345   }
11346   jresult = (void *)result;
11347   return jresult;
11348 }
11349
11350
11351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11352   void * jresult ;
11353   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11354   Dali::Vector3 *result = 0 ;
11355
11356   arg1 = (Dali::Matrix *)jarg1;
11357   {
11358     try {
11359       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11367       };
11368     } catch (...) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11371       };
11372     }
11373   }
11374   jresult = (void *)result;
11375   return jresult;
11376 }
11377
11378
11379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11380   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11381   Dali::Vector4 *arg2 = 0 ;
11382
11383   arg1 = (Dali::Matrix *)jarg1;
11384   arg2 = (Dali::Vector4 *)jarg2;
11385   if (!arg2) {
11386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11387     return ;
11388   }
11389   {
11390     try {
11391       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11392     } catch (std::out_of_range& e) {
11393       {
11394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11395       };
11396     } catch (std::exception& e) {
11397       {
11398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11399       };
11400     } catch (...) {
11401       {
11402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11403       };
11404     }
11405   }
11406 }
11407
11408
11409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11410   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11411   Dali::Vector3 *arg2 = 0 ;
11412
11413   arg1 = (Dali::Matrix *)jarg1;
11414   arg2 = (Dali::Vector3 *)jarg2;
11415   if (!arg2) {
11416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11417     return ;
11418   }
11419   {
11420     try {
11421       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11422     } catch (std::out_of_range& e) {
11423       {
11424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11425       };
11426     } catch (std::exception& e) {
11427       {
11428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11429       };
11430     } catch (...) {
11431       {
11432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11433       };
11434     }
11435   }
11436 }
11437
11438
11439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11440   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11441
11442   arg1 = (Dali::Matrix *)jarg1;
11443   {
11444     try {
11445       (arg1)->OrthoNormalize();
11446     } catch (std::out_of_range& e) {
11447       {
11448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11449       };
11450     } catch (std::exception& e) {
11451       {
11452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11453       };
11454     } catch (...) {
11455       {
11456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11457       };
11458     }
11459   }
11460 }
11461
11462
11463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11464   void * jresult ;
11465   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11466   float *result = 0 ;
11467
11468   arg1 = (Dali::Matrix *)jarg1;
11469   {
11470     try {
11471       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11472     } catch (std::out_of_range& e) {
11473       {
11474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11475       };
11476     } catch (std::exception& e) {
11477       {
11478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11479       };
11480     } catch (...) {
11481       {
11482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11483       };
11484     }
11485   }
11486   jresult = (void *)result;
11487   return jresult;
11488 }
11489
11490
11491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11492   Dali::Matrix *arg1 = 0 ;
11493   Dali::Matrix *arg2 = 0 ;
11494   Dali::Matrix *arg3 = 0 ;
11495
11496   arg1 = (Dali::Matrix *)jarg1;
11497   if (!arg1) {
11498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11499     return ;
11500   }
11501   arg2 = (Dali::Matrix *)jarg2;
11502   if (!arg2) {
11503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11504     return ;
11505   }
11506   arg3 = (Dali::Matrix *)jarg3;
11507   if (!arg3) {
11508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11509     return ;
11510   }
11511   {
11512     try {
11513       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11514     } catch (std::out_of_range& e) {
11515       {
11516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11517       };
11518     } catch (std::exception& e) {
11519       {
11520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11521       };
11522     } catch (...) {
11523       {
11524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11525       };
11526     }
11527   }
11528 }
11529
11530
11531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11532   Dali::Matrix *arg1 = 0 ;
11533   Dali::Matrix *arg2 = 0 ;
11534   Dali::Quaternion *arg3 = 0 ;
11535
11536   arg1 = (Dali::Matrix *)jarg1;
11537   if (!arg1) {
11538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11539     return ;
11540   }
11541   arg2 = (Dali::Matrix *)jarg2;
11542   if (!arg2) {
11543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11544     return ;
11545   }
11546   arg3 = (Dali::Quaternion *)jarg3;
11547   if (!arg3) {
11548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11549     return ;
11550   }
11551   {
11552     try {
11553       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11554     } catch (std::out_of_range& e) {
11555       {
11556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11557       };
11558     } catch (std::exception& e) {
11559       {
11560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11561       };
11562     } catch (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11565       };
11566     }
11567   }
11568 }
11569
11570
11571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11572   void * jresult ;
11573   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11574   Dali::Vector4 *arg2 = 0 ;
11575   Dali::Vector4 result;
11576
11577   arg1 = (Dali::Matrix *)jarg1;
11578   arg2 = (Dali::Vector4 *)jarg2;
11579   if (!arg2) {
11580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11581     return 0;
11582   }
11583   {
11584     try {
11585       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11586     } catch (std::out_of_range& e) {
11587       {
11588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11589       };
11590     } catch (std::exception& e) {
11591       {
11592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11593       };
11594     } catch (...) {
11595       {
11596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11597       };
11598     }
11599   }
11600   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11601   return jresult;
11602 }
11603
11604
11605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11606   unsigned int jresult ;
11607   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11608   Dali::Matrix *arg2 = 0 ;
11609   bool result;
11610
11611   arg1 = (Dali::Matrix *)jarg1;
11612   arg2 = (Dali::Matrix *)jarg2;
11613   if (!arg2) {
11614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11615     return 0;
11616   }
11617   {
11618     try {
11619       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11620     } catch (std::out_of_range& e) {
11621       {
11622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11623       };
11624     } catch (std::exception& e) {
11625       {
11626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11627       };
11628     } catch (...) {
11629       {
11630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11631       };
11632     }
11633   }
11634   jresult = result;
11635   return jresult;
11636 }
11637
11638
11639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11640   unsigned int jresult ;
11641   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11642   Dali::Matrix *arg2 = 0 ;
11643   bool result;
11644
11645   arg1 = (Dali::Matrix *)jarg1;
11646   arg2 = (Dali::Matrix *)jarg2;
11647   if (!arg2) {
11648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11649     return 0;
11650   }
11651   {
11652     try {
11653       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11654     } catch (std::out_of_range& e) {
11655       {
11656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11657       };
11658     } catch (std::exception& e) {
11659       {
11660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11661       };
11662     } catch (...) {
11663       {
11664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11665       };
11666     }
11667   }
11668   jresult = result;
11669   return jresult;
11670 }
11671
11672
11673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11674   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11675   Dali::Vector3 *arg2 = 0 ;
11676   Dali::Quaternion *arg3 = 0 ;
11677   Dali::Vector3 *arg4 = 0 ;
11678
11679   arg1 = (Dali::Matrix *)jarg1;
11680   arg2 = (Dali::Vector3 *)jarg2;
11681   if (!arg2) {
11682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11683     return ;
11684   }
11685   arg3 = (Dali::Quaternion *)jarg3;
11686   if (!arg3) {
11687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11688     return ;
11689   }
11690   arg4 = (Dali::Vector3 *)jarg4;
11691   if (!arg4) {
11692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11693     return ;
11694   }
11695   {
11696     try {
11697       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11698     } catch (std::out_of_range& e) {
11699       {
11700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11701       };
11702     } catch (std::exception& e) {
11703       {
11704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11705       };
11706     } catch (...) {
11707       {
11708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11709       };
11710     }
11711   }
11712 }
11713
11714
11715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11716   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11717   Dali::Vector3 *arg2 = 0 ;
11718   Dali::Quaternion *arg3 = 0 ;
11719   Dali::Vector3 *arg4 = 0 ;
11720
11721   arg1 = (Dali::Matrix *)jarg1;
11722   arg2 = (Dali::Vector3 *)jarg2;
11723   if (!arg2) {
11724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11725     return ;
11726   }
11727   arg3 = (Dali::Quaternion *)jarg3;
11728   if (!arg3) {
11729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11730     return ;
11731   }
11732   arg4 = (Dali::Vector3 *)jarg4;
11733   if (!arg4) {
11734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11735     return ;
11736   }
11737   {
11738     try {
11739       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11740     } catch (std::out_of_range& e) {
11741       {
11742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11743       };
11744     } catch (std::exception& e) {
11745       {
11746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11747       };
11748     } catch (...) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11751       };
11752     }
11753   }
11754 }
11755
11756
11757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11758   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11759   Dali::Vector3 *arg2 = 0 ;
11760   Dali::Vector3 *arg3 = 0 ;
11761   Dali::Vector3 *arg4 = 0 ;
11762   Dali::Vector3 *arg5 = 0 ;
11763
11764   arg1 = (Dali::Matrix *)jarg1;
11765   arg2 = (Dali::Vector3 *)jarg2;
11766   if (!arg2) {
11767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11768     return ;
11769   }
11770   arg3 = (Dali::Vector3 *)jarg3;
11771   if (!arg3) {
11772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11773     return ;
11774   }
11775   arg4 = (Dali::Vector3 *)jarg4;
11776   if (!arg4) {
11777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11778     return ;
11779   }
11780   arg5 = (Dali::Vector3 *)jarg5;
11781   if (!arg5) {
11782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11783     return ;
11784   }
11785   {
11786     try {
11787       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11788     } catch (std::out_of_range& e) {
11789       {
11790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11791       };
11792     } catch (std::exception& e) {
11793       {
11794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11795       };
11796     } catch (...) {
11797       {
11798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11799       };
11800     }
11801   }
11802 }
11803
11804
11805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11806   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11807   Dali::Vector3 *arg2 = 0 ;
11808   Dali::Quaternion *arg3 = 0 ;
11809   Dali::Vector3 *arg4 = 0 ;
11810
11811   arg1 = (Dali::Matrix *)jarg1;
11812   arg2 = (Dali::Vector3 *)jarg2;
11813   if (!arg2) {
11814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11815     return ;
11816   }
11817   arg3 = (Dali::Quaternion *)jarg3;
11818   if (!arg3) {
11819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11820     return ;
11821   }
11822   arg4 = (Dali::Vector3 *)jarg4;
11823   if (!arg4) {
11824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11825     return ;
11826   }
11827   {
11828     try {
11829       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11830     } catch (std::out_of_range& e) {
11831       {
11832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11833       };
11834     } catch (std::exception& e) {
11835       {
11836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11837       };
11838     } catch (...) {
11839       {
11840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11841       };
11842     }
11843   }
11844 }
11845
11846
11847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11848   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11849
11850   arg1 = (Dali::Matrix *)jarg1;
11851   {
11852     try {
11853       delete arg1;
11854     } catch (std::out_of_range& e) {
11855       {
11856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11857       };
11858     } catch (std::exception& e) {
11859       {
11860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11861       };
11862     } catch (...) {
11863       {
11864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11865       };
11866     }
11867   }
11868 }
11869
11870
11871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11872   void * jresult ;
11873   Dali::Matrix3 *result = 0 ;
11874
11875   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11876   jresult = (void *)result;
11877   return jresult;
11878 }
11879
11880
11881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11882   void * jresult ;
11883   Dali::Matrix3 *result = 0 ;
11884
11885   {
11886     try {
11887       result = (Dali::Matrix3 *)new Dali::Matrix3();
11888     } catch (std::out_of_range& e) {
11889       {
11890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11891       };
11892     } catch (std::exception& e) {
11893       {
11894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11895       };
11896     } catch (...) {
11897       {
11898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11899       };
11900     }
11901   }
11902   jresult = (void *)result;
11903   return jresult;
11904 }
11905
11906
11907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11908   void * jresult ;
11909   Dali::Matrix3 *arg1 = 0 ;
11910   Dali::Matrix3 *result = 0 ;
11911
11912   arg1 = (Dali::Matrix3 *)jarg1;
11913   if (!arg1) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11915     return 0;
11916   }
11917   {
11918     try {
11919       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11920     } catch (std::out_of_range& e) {
11921       {
11922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (std::exception& e) {
11925       {
11926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11927       };
11928     } catch (...) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11931       };
11932     }
11933   }
11934   jresult = (void *)result;
11935   return jresult;
11936 }
11937
11938
11939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11940   void * jresult ;
11941   Dali::Matrix *arg1 = 0 ;
11942   Dali::Matrix3 *result = 0 ;
11943
11944   arg1 = (Dali::Matrix *)jarg1;
11945   if (!arg1) {
11946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11947     return 0;
11948   }
11949   {
11950     try {
11951       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
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_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
11972   void * jresult ;
11973   float arg1 ;
11974   float arg2 ;
11975   float arg3 ;
11976   float arg4 ;
11977   float arg5 ;
11978   float arg6 ;
11979   float arg7 ;
11980   float arg8 ;
11981   float arg9 ;
11982   Dali::Matrix3 *result = 0 ;
11983
11984   arg1 = (float)jarg1;
11985   arg2 = (float)jarg2;
11986   arg3 = (float)jarg3;
11987   arg4 = (float)jarg4;
11988   arg5 = (float)jarg5;
11989   arg6 = (float)jarg6;
11990   arg7 = (float)jarg7;
11991   arg8 = (float)jarg8;
11992   arg9 = (float)jarg9;
11993   {
11994     try {
11995       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11996     } catch (std::out_of_range& e) {
11997       {
11998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11999       };
12000     } catch (std::exception& e) {
12001       {
12002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12003       };
12004     } catch (...) {
12005       {
12006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12007       };
12008     }
12009   }
12010   jresult = (void *)result;
12011   return jresult;
12012 }
12013
12014
12015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12016   void * jresult ;
12017   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12018   Dali::Matrix3 *arg2 = 0 ;
12019   Dali::Matrix3 *result = 0 ;
12020
12021   arg1 = (Dali::Matrix3 *)jarg1;
12022   arg2 = (Dali::Matrix3 *)jarg2;
12023   if (!arg2) {
12024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12025     return 0;
12026   }
12027   {
12028     try {
12029       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12030     } catch (std::out_of_range& e) {
12031       {
12032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12033       };
12034     } catch (std::exception& e) {
12035       {
12036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12037       };
12038     } catch (...) {
12039       {
12040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12041       };
12042     }
12043   }
12044   jresult = (void *)result;
12045   return jresult;
12046 }
12047
12048
12049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12050   void * jresult ;
12051   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12052   Dali::Matrix *arg2 = 0 ;
12053   Dali::Matrix3 *result = 0 ;
12054
12055   arg1 = (Dali::Matrix3 *)jarg1;
12056   arg2 = (Dali::Matrix *)jarg2;
12057   if (!arg2) {
12058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12059     return 0;
12060   }
12061   {
12062     try {
12063       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12064     } catch (std::out_of_range& e) {
12065       {
12066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12067       };
12068     } catch (std::exception& e) {
12069       {
12070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12071       };
12072     } catch (...) {
12073       {
12074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12075       };
12076     }
12077   }
12078   jresult = (void *)result;
12079   return jresult;
12080 }
12081
12082
12083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12084   unsigned int jresult ;
12085   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12086   Dali::Matrix3 *arg2 = 0 ;
12087   bool result;
12088
12089   arg1 = (Dali::Matrix3 *)jarg1;
12090   arg2 = (Dali::Matrix3 *)jarg2;
12091   if (!arg2) {
12092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12093     return 0;
12094   }
12095   {
12096     try {
12097       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12098     } catch (std::out_of_range& e) {
12099       {
12100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12101       };
12102     } catch (std::exception& e) {
12103       {
12104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12105       };
12106     } catch (...) {
12107       {
12108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12109       };
12110     }
12111   }
12112   jresult = result;
12113   return jresult;
12114 }
12115
12116
12117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12118   unsigned int jresult ;
12119   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12120   Dali::Matrix3 *arg2 = 0 ;
12121   bool result;
12122
12123   arg1 = (Dali::Matrix3 *)jarg1;
12124   arg2 = (Dali::Matrix3 *)jarg2;
12125   if (!arg2) {
12126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12127     return 0;
12128   }
12129   {
12130     try {
12131       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12132     } catch (std::out_of_range& e) {
12133       {
12134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12135       };
12136     } catch (std::exception& e) {
12137       {
12138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12139       };
12140     } catch (...) {
12141       {
12142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12143       };
12144     }
12145   }
12146   jresult = result;
12147   return jresult;
12148 }
12149
12150
12151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12152   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12153
12154   arg1 = (Dali::Matrix3 *)jarg1;
12155   {
12156     try {
12157       delete arg1;
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12165       };
12166     } catch (...) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12169       };
12170     }
12171   }
12172 }
12173
12174
12175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12176   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12177
12178   arg1 = (Dali::Matrix3 *)jarg1;
12179   {
12180     try {
12181       (arg1)->SetIdentity();
12182     } catch (std::out_of_range& e) {
12183       {
12184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12185       };
12186     } catch (std::exception& e) {
12187       {
12188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12189       };
12190     } catch (...) {
12191       {
12192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12193       };
12194     }
12195   }
12196 }
12197
12198
12199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12200   void * jresult ;
12201   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12202   float *result = 0 ;
12203
12204   arg1 = (Dali::Matrix3 *)jarg1;
12205   {
12206     try {
12207       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12208     } catch (std::out_of_range& e) {
12209       {
12210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12211       };
12212     } catch (std::exception& e) {
12213       {
12214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12215       };
12216     } catch (...) {
12217       {
12218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12219       };
12220     }
12221   }
12222   jresult = (void *)result;
12223   return jresult;
12224 }
12225
12226
12227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12228   unsigned int jresult ;
12229   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12230   bool result;
12231
12232   arg1 = (Dali::Matrix3 *)jarg1;
12233   {
12234     try {
12235       result = (bool)(arg1)->Invert();
12236     } catch (std::out_of_range& e) {
12237       {
12238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12239       };
12240     } catch (std::exception& e) {
12241       {
12242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12243       };
12244     } catch (...) {
12245       {
12246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12247       };
12248     }
12249   }
12250   jresult = result;
12251   return jresult;
12252 }
12253
12254
12255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12256   unsigned int jresult ;
12257   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12258   bool result;
12259
12260   arg1 = (Dali::Matrix3 *)jarg1;
12261   {
12262     try {
12263       result = (bool)(arg1)->Transpose();
12264     } catch (std::out_of_range& e) {
12265       {
12266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12267       };
12268     } catch (std::exception& e) {
12269       {
12270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12271       };
12272     } catch (...) {
12273       {
12274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12275       };
12276     }
12277   }
12278   jresult = result;
12279   return jresult;
12280 }
12281
12282
12283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12284   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12285   float arg2 ;
12286
12287   arg1 = (Dali::Matrix3 *)jarg1;
12288   arg2 = (float)jarg2;
12289   {
12290     try {
12291       (arg1)->Scale(arg2);
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12299       };
12300     } catch (...) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12303       };
12304     }
12305   }
12306 }
12307
12308
12309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12310   float jresult ;
12311   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12312   float result;
12313
12314   arg1 = (Dali::Matrix3 *)jarg1;
12315   {
12316     try {
12317       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12318     } catch (std::out_of_range& e) {
12319       {
12320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12321       };
12322     } catch (std::exception& e) {
12323       {
12324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12325       };
12326     } catch (...) {
12327       {
12328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12329       };
12330     }
12331   }
12332   jresult = result;
12333   return jresult;
12334 }
12335
12336
12337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12338   unsigned int jresult ;
12339   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12340   bool result;
12341
12342   arg1 = (Dali::Matrix3 *)jarg1;
12343   {
12344     try {
12345       result = (bool)(arg1)->ScaledInverseTranspose();
12346     } catch (std::out_of_range& e) {
12347       {
12348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12349       };
12350     } catch (std::exception& e) {
12351       {
12352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12353       };
12354     } catch (...) {
12355       {
12356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12357       };
12358     }
12359   }
12360   jresult = result;
12361   return jresult;
12362 }
12363
12364
12365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12366   Dali::Matrix3 *arg1 = 0 ;
12367   Dali::Matrix3 *arg2 = 0 ;
12368   Dali::Matrix3 *arg3 = 0 ;
12369
12370   arg1 = (Dali::Matrix3 *)jarg1;
12371   if (!arg1) {
12372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12373     return ;
12374   }
12375   arg2 = (Dali::Matrix3 *)jarg2;
12376   if (!arg2) {
12377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12378     return ;
12379   }
12380   arg3 = (Dali::Matrix3 *)jarg3;
12381   if (!arg3) {
12382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12383     return ;
12384   }
12385   {
12386     try {
12387       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12388     } catch (std::out_of_range& e) {
12389       {
12390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12391       };
12392     } catch (std::exception& e) {
12393       {
12394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12395       };
12396     } catch (...) {
12397       {
12398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12399       };
12400     }
12401   }
12402 }
12403
12404
12405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12406   float jresult ;
12407   float arg1 ;
12408   float arg2 ;
12409   float result;
12410
12411   arg1 = (float)jarg1;
12412   arg2 = (float)jarg2;
12413   {
12414     try {
12415       result = (float)Dali::Random::Range(arg1,arg2);
12416     } catch (std::out_of_range& e) {
12417       {
12418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12419       };
12420     } catch (std::exception& e) {
12421       {
12422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12423       };
12424     } catch (...) {
12425       {
12426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12427       };
12428     }
12429   }
12430   jresult = result;
12431   return jresult;
12432 }
12433
12434
12435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12436   void * jresult ;
12437   Dali::Vector4 result;
12438
12439   {
12440     try {
12441       result = Dali::Random::Axis();
12442     } catch (std::out_of_range& e) {
12443       {
12444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12445       };
12446     } catch (std::exception& e) {
12447       {
12448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12449       };
12450     } catch (...) {
12451       {
12452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12453       };
12454     }
12455   }
12456   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12457   return jresult;
12458 }
12459
12460
12461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12462   void * jresult ;
12463   Dali::AngleAxis *result = 0 ;
12464
12465   {
12466     try {
12467       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12468     } catch (std::out_of_range& e) {
12469       {
12470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12471       };
12472     } catch (std::exception& e) {
12473       {
12474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12475       };
12476     } catch (...) {
12477       {
12478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12479       };
12480     }
12481   }
12482   jresult = (void *)result;
12483   return jresult;
12484 }
12485
12486
12487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12488   void * jresult ;
12489   Dali::Radian arg1 ;
12490   Dali::Vector3 *arg2 = 0 ;
12491   Dali::Radian *argp1 ;
12492   Dali::AngleAxis *result = 0 ;
12493
12494   argp1 = (Dali::Radian *)jarg1;
12495   if (!argp1) {
12496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12497     return 0;
12498   }
12499   arg1 = *argp1;
12500   arg2 = (Dali::Vector3 *)jarg2;
12501   if (!arg2) {
12502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12503     return 0;
12504   }
12505   {
12506     try {
12507       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12508     } catch (std::out_of_range& e) {
12509       {
12510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12511       };
12512     } catch (std::exception& e) {
12513       {
12514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (...) {
12517       {
12518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12519       };
12520     }
12521   }
12522   jresult = (void *)result;
12523   return jresult;
12524 }
12525
12526
12527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12528   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12529   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12530
12531   arg1 = (Dali::AngleAxis *)jarg1;
12532   arg2 = (Dali::Radian *)jarg2;
12533   if (arg1) (arg1)->angle = *arg2;
12534 }
12535
12536
12537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12538   void * jresult ;
12539   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12540   Dali::Radian *result = 0 ;
12541
12542   arg1 = (Dali::AngleAxis *)jarg1;
12543   result = (Dali::Radian *)& ((arg1)->angle);
12544   jresult = (void *)result;
12545   return jresult;
12546 }
12547
12548
12549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12550   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12551   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12552
12553   arg1 = (Dali::AngleAxis *)jarg1;
12554   arg2 = (Dali::Vector3 *)jarg2;
12555   if (arg1) (arg1)->axis = *arg2;
12556 }
12557
12558
12559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12560   void * jresult ;
12561   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12562   Dali::Vector3 *result = 0 ;
12563
12564   arg1 = (Dali::AngleAxis *)jarg1;
12565   result = (Dali::Vector3 *)& ((arg1)->axis);
12566   jresult = (void *)result;
12567   return jresult;
12568 }
12569
12570
12571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12572   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12573
12574   arg1 = (Dali::AngleAxis *)jarg1;
12575   {
12576     try {
12577       delete arg1;
12578     } catch (std::out_of_range& e) {
12579       {
12580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12581       };
12582     } catch (std::exception& e) {
12583       {
12584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12589       };
12590     }
12591   }
12592 }
12593
12594
12595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12596   unsigned int jresult ;
12597   Dali::AngleAxis *arg1 = 0 ;
12598   Dali::AngleAxis *arg2 = 0 ;
12599   bool result;
12600
12601   arg1 = (Dali::AngleAxis *)jarg1;
12602   if (!arg1) {
12603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12604     return 0;
12605   }
12606   arg2 = (Dali::AngleAxis *)jarg2;
12607   if (!arg2) {
12608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12609     return 0;
12610   }
12611   {
12612     try {
12613       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12614     } catch (std::out_of_range& e) {
12615       {
12616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12617       };
12618     } catch (std::exception& e) {
12619       {
12620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12621       };
12622     } catch (...) {
12623       {
12624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12625       };
12626     }
12627   }
12628   jresult = result;
12629   return jresult;
12630 }
12631
12632
12633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12634   unsigned int jresult ;
12635   unsigned int arg1 ;
12636   unsigned int result;
12637
12638   arg1 = (unsigned int)jarg1;
12639   {
12640     try {
12641       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12642     } catch (std::out_of_range& e) {
12643       {
12644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12645       };
12646     } catch (std::exception& e) {
12647       {
12648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12653       };
12654     }
12655   }
12656   jresult = result;
12657   return jresult;
12658 }
12659
12660
12661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12662   unsigned int jresult ;
12663   unsigned int arg1 ;
12664   bool result;
12665
12666   arg1 = (unsigned int)jarg1;
12667   {
12668     try {
12669       result = (bool)Dali::IsPowerOfTwo(arg1);
12670     } catch (std::out_of_range& e) {
12671       {
12672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12673       };
12674     } catch (std::exception& e) {
12675       {
12676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12677       };
12678     } catch (...) {
12679       {
12680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12681       };
12682     }
12683   }
12684   jresult = result;
12685   return jresult;
12686 }
12687
12688
12689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12690   float jresult ;
12691   float arg1 ;
12692   float arg2 ;
12693   float result;
12694
12695   arg1 = (float)jarg1;
12696   arg2 = (float)jarg2;
12697   {
12698     try {
12699       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12700     } catch (std::out_of_range& e) {
12701       {
12702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12703       };
12704     } catch (std::exception& e) {
12705       {
12706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12707       };
12708     } catch (...) {
12709       {
12710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12711       };
12712     }
12713   }
12714   jresult = result;
12715   return jresult;
12716 }
12717
12718
12719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12720   unsigned int jresult ;
12721   float arg1 ;
12722   bool result;
12723
12724   arg1 = (float)jarg1;
12725   {
12726     try {
12727       result = (bool)Dali::EqualsZero(arg1);
12728     } catch (std::out_of_range& e) {
12729       {
12730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12731       };
12732     } catch (std::exception& e) {
12733       {
12734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12735       };
12736     } catch (...) {
12737       {
12738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12739       };
12740     }
12741   }
12742   jresult = result;
12743   return jresult;
12744 }
12745
12746
12747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12748   unsigned int jresult ;
12749   float arg1 ;
12750   float arg2 ;
12751   bool result;
12752
12753   arg1 = (float)jarg1;
12754   arg2 = (float)jarg2;
12755   {
12756     try {
12757       result = (bool)Dali::Equals(arg1,arg2);
12758     } catch (std::out_of_range& e) {
12759       {
12760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12761       };
12762     } catch (std::exception& e) {
12763       {
12764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12765       };
12766     } catch (...) {
12767       {
12768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12769       };
12770     }
12771   }
12772   jresult = result;
12773   return jresult;
12774 }
12775
12776
12777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12778   unsigned int jresult ;
12779   float arg1 ;
12780   float arg2 ;
12781   float arg3 ;
12782   bool result;
12783
12784   arg1 = (float)jarg1;
12785   arg2 = (float)jarg2;
12786   arg3 = (float)jarg3;
12787   {
12788     try {
12789       result = (bool)Dali::Equals(arg1,arg2,arg3);
12790     } catch (std::out_of_range& e) {
12791       {
12792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12793       };
12794     } catch (std::exception& e) {
12795       {
12796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12797       };
12798     } catch (...) {
12799       {
12800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12801       };
12802     }
12803   }
12804   jresult = result;
12805   return jresult;
12806 }
12807
12808
12809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12810   float jresult ;
12811   float arg1 ;
12812   int arg2 ;
12813   float result;
12814
12815   arg1 = (float)jarg1;
12816   arg2 = (int)jarg2;
12817   {
12818     try {
12819       result = (float)Dali::Round(arg1,arg2);
12820     } catch (std::out_of_range& e) {
12821       {
12822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12823       };
12824     } catch (std::exception& e) {
12825       {
12826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12827       };
12828     } catch (...) {
12829       {
12830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12831       };
12832     }
12833   }
12834   jresult = result;
12835   return jresult;
12836 }
12837
12838
12839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12840   float jresult ;
12841   float arg1 ;
12842   float arg2 ;
12843   float arg3 ;
12844   float result;
12845
12846   arg1 = (float)jarg1;
12847   arg2 = (float)jarg2;
12848   arg3 = (float)jarg3;
12849   {
12850     try {
12851       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12852     } catch (std::out_of_range& e) {
12853       {
12854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12855       };
12856     } catch (std::exception& e) {
12857       {
12858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12863       };
12864     }
12865   }
12866   jresult = result;
12867   return jresult;
12868 }
12869
12870
12871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12872   float jresult ;
12873   float arg1 ;
12874   float arg2 ;
12875   float arg3 ;
12876   float arg4 ;
12877   float result;
12878
12879   arg1 = (float)jarg1;
12880   arg2 = (float)jarg2;
12881   arg3 = (float)jarg3;
12882   arg4 = (float)jarg4;
12883   {
12884     try {
12885       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12886     } catch (std::out_of_range& e) {
12887       {
12888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12889       };
12890     } catch (std::exception& e) {
12891       {
12892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12893       };
12894     } catch (...) {
12895       {
12896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12897       };
12898     }
12899   }
12900   jresult = result;
12901   return jresult;
12902 }
12903
12904
12905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12906   int jresult ;
12907   int result;
12908
12909   result = (int)(int)Dali::Property::INVALID_INDEX;
12910   jresult = result;
12911   return jresult;
12912 }
12913
12914
12915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12916   int jresult ;
12917   int result;
12918
12919   result = (int)(int)Dali::Property::INVALID_KEY;
12920   jresult = result;
12921   return jresult;
12922 }
12923
12924
12925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12926   int jresult ;
12927   int result;
12928
12929   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12930   jresult = result;
12931   return jresult;
12932 }
12933
12934
12935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12936   void * jresult ;
12937   Dali::Handle *arg1 = 0 ;
12938   Dali::Property::Index arg2 ;
12939   Dali::Property *result = 0 ;
12940
12941   arg1 = (Dali::Handle *)jarg1;
12942   if (!arg1) {
12943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12944     return 0;
12945   }
12946   arg2 = (Dali::Property::Index)jarg2;
12947   {
12948     try {
12949       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
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 = (void *)result;
12965   return jresult;
12966 }
12967
12968
12969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12970   void * jresult ;
12971   Dali::Handle *arg1 = 0 ;
12972   Dali::Property::Index arg2 ;
12973   int arg3 ;
12974   Dali::Property *result = 0 ;
12975
12976   arg1 = (Dali::Handle *)jarg1;
12977   if (!arg1) {
12978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12979     return 0;
12980   }
12981   arg2 = (Dali::Property::Index)jarg2;
12982   arg3 = (int)jarg3;
12983   {
12984     try {
12985       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12986     } catch (std::out_of_range& e) {
12987       {
12988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12989       };
12990     } catch (std::exception& e) {
12991       {
12992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12993       };
12994     } catch (...) {
12995       {
12996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12997       };
12998     }
12999   }
13000   jresult = (void *)result;
13001   return jresult;
13002 }
13003
13004
13005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13006   void * jresult ;
13007   Dali::Handle *arg1 = 0 ;
13008   std::string *arg2 = 0 ;
13009   Dali::Property *result = 0 ;
13010
13011   arg1 = (Dali::Handle *)jarg1;
13012   if (!arg1) {
13013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13014     return 0;
13015   }
13016   if (!jarg2) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13018     return 0;
13019   }
13020   std::string arg2_str(jarg2);
13021   arg2 = &arg2_str;
13022   {
13023     try {
13024       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13025     } catch (std::out_of_range& e) {
13026       {
13027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13028       };
13029     } catch (std::exception& e) {
13030       {
13031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13032       };
13033     } catch (...) {
13034       {
13035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13036       };
13037     }
13038   }
13039   jresult = (void *)result;
13040
13041   //argout typemap for const std::string&
13042
13043   return jresult;
13044 }
13045
13046
13047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13048   void * jresult ;
13049   Dali::Handle *arg1 = 0 ;
13050   std::string *arg2 = 0 ;
13051   int arg3 ;
13052   Dali::Property *result = 0 ;
13053
13054   arg1 = (Dali::Handle *)jarg1;
13055   if (!arg1) {
13056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13057     return 0;
13058   }
13059   if (!jarg2) {
13060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13061     return 0;
13062   }
13063   std::string arg2_str(jarg2);
13064   arg2 = &arg2_str;
13065   arg3 = (int)jarg3;
13066   {
13067     try {
13068       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13069     } catch (std::out_of_range& e) {
13070       {
13071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13072       };
13073     } catch (std::exception& e) {
13074       {
13075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13076       };
13077     } catch (...) {
13078       {
13079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13080       };
13081     }
13082   }
13083   jresult = (void *)result;
13084
13085   //argout typemap for const std::string&
13086
13087   return jresult;
13088 }
13089
13090
13091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13092   Dali::Property *arg1 = (Dali::Property *) 0 ;
13093
13094   arg1 = (Dali::Property *)jarg1;
13095   {
13096     try {
13097       delete arg1;
13098     } catch (std::out_of_range& e) {
13099       {
13100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13101       };
13102     } catch (std::exception& e) {
13103       {
13104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13105       };
13106     } catch (...) {
13107       {
13108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13109       };
13110     }
13111   }
13112 }
13113
13114
13115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13116   Dali::Property *arg1 = (Dali::Property *) 0 ;
13117   Dali::Handle *arg2 = 0 ;
13118
13119   arg1 = (Dali::Property *)jarg1;
13120   arg2 = (Dali::Handle *)jarg2;
13121   if (!arg2) {
13122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13123     return ;
13124   }
13125   if (arg1) (arg1)->object = *arg2;
13126 }
13127
13128
13129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13130   void * jresult ;
13131   Dali::Property *arg1 = (Dali::Property *) 0 ;
13132   Dali::Handle *result = 0 ;
13133
13134   arg1 = (Dali::Property *)jarg1;
13135   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13136   jresult = (void *)result;
13137   return jresult;
13138 }
13139
13140
13141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13142   Dali::Property *arg1 = (Dali::Property *) 0 ;
13143   Dali::Property::Index arg2 ;
13144
13145   arg1 = (Dali::Property *)jarg1;
13146   arg2 = (Dali::Property::Index)jarg2;
13147   if (arg1) (arg1)->propertyIndex = arg2;
13148 }
13149
13150
13151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13152   int jresult ;
13153   Dali::Property *arg1 = (Dali::Property *) 0 ;
13154   Dali::Property::Index result;
13155
13156   arg1 = (Dali::Property *)jarg1;
13157   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13158   jresult = result;
13159   return jresult;
13160 }
13161
13162
13163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13164   Dali::Property *arg1 = (Dali::Property *) 0 ;
13165   int arg2 ;
13166
13167   arg1 = (Dali::Property *)jarg1;
13168   arg2 = (int)jarg2;
13169   if (arg1) (arg1)->componentIndex = arg2;
13170 }
13171
13172
13173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13174   int jresult ;
13175   Dali::Property *arg1 = (Dali::Property *) 0 ;
13176   int result;
13177
13178   arg1 = (Dali::Property *)jarg1;
13179   result = (int) ((arg1)->componentIndex);
13180   jresult = result;
13181   return jresult;
13182 }
13183
13184
13185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13186   void * jresult ;
13187   Dali::Property::Array *result = 0 ;
13188
13189   {
13190     try {
13191       result = (Dali::Property::Array *)new Dali::Property::Array();
13192     } catch (std::out_of_range& e) {
13193       {
13194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13195       };
13196     } catch (std::exception& e) {
13197       {
13198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13199       };
13200     } catch (...) {
13201       {
13202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13203       };
13204     }
13205   }
13206   jresult = (void *)result;
13207   return jresult;
13208 }
13209
13210
13211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13212   void * jresult ;
13213   Dali::Property::Array *arg1 = 0 ;
13214   Dali::Property::Array *result = 0 ;
13215
13216   arg1 = (Dali::Property::Array *)jarg1;
13217   if (!arg1) {
13218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13219     return 0;
13220   }
13221   {
13222     try {
13223       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13224     } catch (std::out_of_range& e) {
13225       {
13226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13227       };
13228     } catch (std::exception& e) {
13229       {
13230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13231       };
13232     } catch (...) {
13233       {
13234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13235       };
13236     }
13237   }
13238   jresult = (void *)result;
13239   return jresult;
13240 }
13241
13242
13243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13244   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13245
13246   arg1 = (Dali::Property::Array *)jarg1;
13247   {
13248     try {
13249       delete arg1;
13250     } catch (std::out_of_range& e) {
13251       {
13252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (std::exception& e) {
13255       {
13256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13257       };
13258     } catch (...) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13261       };
13262     }
13263   }
13264 }
13265
13266
13267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13268   unsigned long jresult ;
13269   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13270   Dali::Property::Array::SizeType result;
13271
13272   arg1 = (Dali::Property::Array *)jarg1;
13273   {
13274     try {
13275       result = ((Dali::Property::Array const *)arg1)->Size();
13276     } catch (std::out_of_range& e) {
13277       {
13278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13279       };
13280     } catch (std::exception& e) {
13281       {
13282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13283       };
13284     } catch (...) {
13285       {
13286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13287       };
13288     }
13289   }
13290   jresult = (unsigned long)result;
13291   return jresult;
13292 }
13293
13294
13295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13296   unsigned long jresult ;
13297   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13298   Dali::Property::Array::SizeType result;
13299
13300   arg1 = (Dali::Property::Array *)jarg1;
13301   {
13302     try {
13303       result = ((Dali::Property::Array const *)arg1)->Count();
13304     } catch (std::out_of_range& e) {
13305       {
13306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13307       };
13308     } catch (std::exception& e) {
13309       {
13310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13311       };
13312     } catch (...) {
13313       {
13314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13315       };
13316     }
13317   }
13318   jresult = (unsigned long)result;
13319   return jresult;
13320 }
13321
13322
13323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13324   unsigned int jresult ;
13325   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13326   bool result;
13327
13328   arg1 = (Dali::Property::Array *)jarg1;
13329   {
13330     try {
13331       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13332     } catch (std::out_of_range& e) {
13333       {
13334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13335       };
13336     } catch (std::exception& e) {
13337       {
13338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13339       };
13340     } catch (...) {
13341       {
13342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13343       };
13344     }
13345   }
13346   jresult = result;
13347   return jresult;
13348 }
13349
13350
13351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13352   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13353
13354   arg1 = (Dali::Property::Array *)jarg1;
13355   {
13356     try {
13357       (arg1)->Clear();
13358     } catch (std::out_of_range& e) {
13359       {
13360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13361       };
13362     } catch (std::exception& e) {
13363       {
13364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13365       };
13366     } catch (...) {
13367       {
13368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13369       };
13370     }
13371   }
13372 }
13373
13374
13375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13376   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13377   Dali::Property::Array::SizeType arg2 ;
13378
13379   arg1 = (Dali::Property::Array *)jarg1;
13380   arg2 = (Dali::Property::Array::SizeType)jarg2;
13381   {
13382     try {
13383       (arg1)->Reserve(arg2);
13384     } catch (std::out_of_range& e) {
13385       {
13386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13387       };
13388     } catch (std::exception& e) {
13389       {
13390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13391       };
13392     } catch (...) {
13393       {
13394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13395       };
13396     }
13397   }
13398 }
13399
13400
13401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13402   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13403   Dali::Property::Array::SizeType arg2 ;
13404
13405   arg1 = (Dali::Property::Array *)jarg1;
13406   arg2 = (Dali::Property::Array::SizeType)jarg2;
13407   {
13408     try {
13409       (arg1)->Resize(arg2);
13410     } catch (std::out_of_range& e) {
13411       {
13412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13413       };
13414     } catch (std::exception& e) {
13415       {
13416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13417       };
13418     } catch (...) {
13419       {
13420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13421       };
13422     }
13423   }
13424 }
13425
13426
13427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13428   unsigned long jresult ;
13429   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13430   Dali::Property::Array::SizeType result;
13431
13432   arg1 = (Dali::Property::Array *)jarg1;
13433   {
13434     try {
13435       result = (arg1)->Capacity();
13436     } catch (std::out_of_range& e) {
13437       {
13438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13439       };
13440     } catch (std::exception& e) {
13441       {
13442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13443       };
13444     } catch (...) {
13445       {
13446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13447       };
13448     }
13449   }
13450   jresult = (unsigned long)result;
13451   return jresult;
13452 }
13453
13454
13455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13456   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13457   Dali::Property::Value *arg2 = 0 ;
13458
13459   arg1 = (Dali::Property::Array *)jarg1;
13460   arg2 = (Dali::Property::Value *)jarg2;
13461   if (!arg2) {
13462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13463     return ;
13464   }
13465   {
13466     try {
13467       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13468     } catch (std::out_of_range& e) {
13469       {
13470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13471       };
13472     } catch (std::exception& e) {
13473       {
13474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13475       };
13476     } catch (...) {
13477       {
13478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13479       };
13480     }
13481   }
13482 }
13483
13484
13485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13486   void * jresult ;
13487   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13488   Dali::Property::Value *arg2 = 0 ;
13489   Dali::Property::Array *result = 0 ;
13490
13491   arg1 = (Dali::Property::Array *)jarg1;
13492   arg2 = (Dali::Property::Value *)jarg2;
13493   if (!arg2) {
13494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13495     return 0;
13496   }
13497   {
13498     try {
13499       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
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 = (void *)result;
13515   return jresult;
13516 }
13517
13518
13519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13520   void * jresult ;
13521   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13522   Dali::Property::Array::SizeType arg2 ;
13523   Dali::Property::Value *result = 0 ;
13524
13525   arg1 = (Dali::Property::Array *)jarg1;
13526   arg2 = (Dali::Property::Array::SizeType)jarg2;
13527   {
13528     try {
13529       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13530     } catch (std::out_of_range& e) {
13531       {
13532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13533       };
13534     } catch (std::exception& e) {
13535       {
13536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13537       };
13538     } catch (...) {
13539       {
13540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13541       };
13542     }
13543   }
13544   jresult = (void *)result;
13545   return jresult;
13546 }
13547
13548
13549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13550   void * jresult ;
13551   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13552   Dali::Property::Array::SizeType arg2 ;
13553   Dali::Property::Value *result = 0 ;
13554
13555   arg1 = (Dali::Property::Array *)jarg1;
13556   arg2 = (Dali::Property::Array::SizeType)jarg2;
13557   {
13558     try {
13559       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13560     } catch (std::out_of_range& e) {
13561       {
13562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13563       };
13564     } catch (std::exception& e) {
13565       {
13566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (...) {
13569       {
13570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13571       };
13572     }
13573   }
13574   jresult = (void *)result;
13575   return jresult;
13576 }
13577
13578
13579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13580   void * jresult ;
13581   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13582   Dali::Property::Array *arg2 = 0 ;
13583   Dali::Property::Array *result = 0 ;
13584
13585   arg1 = (Dali::Property::Array *)jarg1;
13586   arg2 = (Dali::Property::Array *)jarg2;
13587   if (!arg2) {
13588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13589     return 0;
13590   }
13591   {
13592     try {
13593       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*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_Key_type_set(void * jarg1, int jarg2) {
13614   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13615   enum Dali::Property::Key::Type arg2 ;
13616
13617   arg1 = (Dali::Property::Key *)jarg1;
13618   arg2 = (enum Dali::Property::Key::Type)jarg2;
13619   if (arg1) (arg1)->type = arg2;
13620 }
13621
13622
13623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13624   int jresult ;
13625   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13626   enum Dali::Property::Key::Type result;
13627
13628   arg1 = (Dali::Property::Key *)jarg1;
13629   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13630   jresult = (int)result;
13631   return jresult;
13632 }
13633
13634
13635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13636   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13637   Dali::Property::Index arg2 ;
13638
13639   arg1 = (Dali::Property::Key *)jarg1;
13640   arg2 = (Dali::Property::Index)jarg2;
13641   if (arg1) (arg1)->indexKey = arg2;
13642 }
13643
13644
13645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13646   int jresult ;
13647   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13648   Dali::Property::Index result;
13649
13650   arg1 = (Dali::Property::Key *)jarg1;
13651   result = (Dali::Property::Index) ((arg1)->indexKey);
13652   jresult = result;
13653   return jresult;
13654 }
13655
13656
13657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13658   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13659   std::string *arg2 = 0 ;
13660
13661   arg1 = (Dali::Property::Key *)jarg1;
13662   if (!jarg2) {
13663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13664     return ;
13665   }
13666   std::string arg2_str(jarg2);
13667   arg2 = &arg2_str;
13668   if (arg1) (arg1)->stringKey = *arg2;
13669
13670   //argout typemap for const std::string&
13671
13672 }
13673
13674
13675 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13676   char * jresult ;
13677   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13678   std::string *result = 0 ;
13679
13680   arg1 = (Dali::Property::Key *)jarg1;
13681   result = (std::string *) & ((arg1)->stringKey);
13682   jresult = SWIG_csharp_string_callback(result->c_str());
13683   return jresult;
13684 }
13685
13686
13687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13688   void * jresult ;
13689   std::string *arg1 = 0 ;
13690   Dali::Property::Key *result = 0 ;
13691
13692   if (!jarg1) {
13693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13694     return 0;
13695   }
13696   std::string arg1_str(jarg1);
13697   arg1 = &arg1_str;
13698   {
13699     try {
13700       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13701     } catch (std::out_of_range& e) {
13702       {
13703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13704       };
13705     } catch (std::exception& e) {
13706       {
13707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13708       };
13709     } catch (...) {
13710       {
13711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13712       };
13713     }
13714   }
13715   jresult = (void *)result;
13716
13717   //argout typemap for const std::string&
13718
13719   return jresult;
13720 }
13721
13722
13723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13724   void * jresult ;
13725   Dali::Property::Index arg1 ;
13726   Dali::Property::Key *result = 0 ;
13727
13728   arg1 = (Dali::Property::Index)jarg1;
13729   {
13730     try {
13731       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13732     } catch (std::out_of_range& e) {
13733       {
13734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13735       };
13736     } catch (std::exception& e) {
13737       {
13738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13739       };
13740     } catch (...) {
13741       {
13742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13743       };
13744     }
13745   }
13746   jresult = (void *)result;
13747   return jresult;
13748 }
13749
13750
13751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13752   unsigned int jresult ;
13753   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13754   std::string *arg2 = 0 ;
13755   bool result;
13756
13757   arg1 = (Dali::Property::Key *)jarg1;
13758   if (!jarg2) {
13759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13760     return 0;
13761   }
13762   std::string arg2_str(jarg2);
13763   arg2 = &arg2_str;
13764   {
13765     try {
13766       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13767     } catch (std::out_of_range& e) {
13768       {
13769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13770       };
13771     } catch (std::exception& e) {
13772       {
13773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13774       };
13775     } catch (...) {
13776       {
13777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13778       };
13779     }
13780   }
13781   jresult = result;
13782
13783   //argout typemap for const std::string&
13784
13785   return jresult;
13786 }
13787
13788
13789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13790   unsigned int jresult ;
13791   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13792   Dali::Property::Index arg2 ;
13793   bool result;
13794
13795   arg1 = (Dali::Property::Key *)jarg1;
13796   arg2 = (Dali::Property::Index)jarg2;
13797   {
13798     try {
13799       result = (bool)(arg1)->operator ==(arg2);
13800     } catch (std::out_of_range& e) {
13801       {
13802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13803       };
13804     } catch (std::exception& e) {
13805       {
13806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13807       };
13808     } catch (...) {
13809       {
13810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13811       };
13812     }
13813   }
13814   jresult = result;
13815   return jresult;
13816 }
13817
13818
13819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13820   unsigned int jresult ;
13821   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13822   Dali::Property::Key *arg2 = 0 ;
13823   bool result;
13824
13825   arg1 = (Dali::Property::Key *)jarg1;
13826   arg2 = (Dali::Property::Key *)jarg2;
13827   if (!arg2) {
13828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13829     return 0;
13830   }
13831   {
13832     try {
13833       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13834     } catch (std::out_of_range& e) {
13835       {
13836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13837       };
13838     } catch (std::exception& e) {
13839       {
13840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13841       };
13842     } catch (...) {
13843       {
13844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13845       };
13846     }
13847   }
13848   jresult = result;
13849   return jresult;
13850 }
13851
13852
13853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13854   unsigned int jresult ;
13855   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13856   std::string *arg2 = 0 ;
13857   bool result;
13858
13859   arg1 = (Dali::Property::Key *)jarg1;
13860   if (!jarg2) {
13861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13862     return 0;
13863   }
13864   std::string arg2_str(jarg2);
13865   arg2 = &arg2_str;
13866   {
13867     try {
13868       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13869     } catch (std::out_of_range& e) {
13870       {
13871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13872       };
13873     } catch (std::exception& e) {
13874       {
13875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13876       };
13877     } catch (...) {
13878       {
13879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13880       };
13881     }
13882   }
13883   jresult = result;
13884
13885   //argout typemap for const std::string&
13886
13887   return jresult;
13888 }
13889
13890
13891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13892   unsigned int jresult ;
13893   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13894   Dali::Property::Index arg2 ;
13895   bool result;
13896
13897   arg1 = (Dali::Property::Key *)jarg1;
13898   arg2 = (Dali::Property::Index)jarg2;
13899   {
13900     try {
13901       result = (bool)(arg1)->operator !=(arg2);
13902     } catch (std::out_of_range& e) {
13903       {
13904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13905       };
13906     } catch (std::exception& e) {
13907       {
13908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13909       };
13910     } catch (...) {
13911       {
13912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13913       };
13914     }
13915   }
13916   jresult = result;
13917   return jresult;
13918 }
13919
13920
13921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13922   unsigned int jresult ;
13923   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13924   Dali::Property::Key *arg2 = 0 ;
13925   bool result;
13926
13927   arg1 = (Dali::Property::Key *)jarg1;
13928   arg2 = (Dali::Property::Key *)jarg2;
13929   if (!arg2) {
13930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13931     return 0;
13932   }
13933   {
13934     try {
13935       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13936     } catch (std::out_of_range& e) {
13937       {
13938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13939       };
13940     } catch (std::exception& e) {
13941       {
13942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13943       };
13944     } catch (...) {
13945       {
13946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13947       };
13948     }
13949   }
13950   jresult = result;
13951   return jresult;
13952 }
13953
13954
13955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13956   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13957
13958   arg1 = (Dali::Property::Key *)jarg1;
13959   {
13960     try {
13961       delete arg1;
13962     } catch (std::out_of_range& e) {
13963       {
13964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13965       };
13966     } catch (std::exception& e) {
13967       {
13968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13969       };
13970     } catch (...) {
13971       {
13972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13973       };
13974     }
13975   }
13976 }
13977
13978
13979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13980   void * jresult ;
13981   Dali::Property::Map *result = 0 ;
13982
13983   {
13984     try {
13985       result = (Dali::Property::Map *)new Dali::Property::Map();
13986     } catch (std::out_of_range& e) {
13987       {
13988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13989       };
13990     } catch (std::exception& e) {
13991       {
13992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13993       };
13994     } catch (...) {
13995       {
13996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13997       };
13998     }
13999   }
14000   jresult = (void *)result;
14001   return jresult;
14002 }
14003
14004
14005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14006   void * jresult ;
14007   Dali::Property::Map *arg1 = 0 ;
14008   Dali::Property::Map *result = 0 ;
14009
14010   arg1 = (Dali::Property::Map *)jarg1;
14011   if (!arg1) {
14012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14013     return 0;
14014   }
14015   {
14016     try {
14017       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14018     } catch (std::out_of_range& e) {
14019       {
14020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14021       };
14022     } catch (std::exception& e) {
14023       {
14024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14025       };
14026     } catch (...) {
14027       {
14028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14029       };
14030     }
14031   }
14032   jresult = (void *)result;
14033   return jresult;
14034 }
14035
14036
14037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14038   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14039
14040   arg1 = (Dali::Property::Map *)jarg1;
14041   {
14042     try {
14043       delete arg1;
14044     } catch (std::out_of_range& e) {
14045       {
14046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14047       };
14048     } catch (std::exception& e) {
14049       {
14050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14051       };
14052     } catch (...) {
14053       {
14054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14055       };
14056     }
14057   }
14058 }
14059
14060
14061 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14062   unsigned long jresult ;
14063   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14064   Dali::Property::Map::SizeType result;
14065
14066   arg1 = (Dali::Property::Map *)jarg1;
14067   {
14068     try {
14069       result = ((Dali::Property::Map const *)arg1)->Count();
14070     } catch (std::out_of_range& e) {
14071       {
14072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14073       };
14074     } catch (std::exception& e) {
14075       {
14076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14077       };
14078     } catch (...) {
14079       {
14080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14081       };
14082     }
14083   }
14084   jresult = (unsigned long)result;
14085   return jresult;
14086 }
14087
14088
14089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14090   unsigned int jresult ;
14091   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14092   bool result;
14093
14094   arg1 = (Dali::Property::Map *)jarg1;
14095   {
14096     try {
14097       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14098     } catch (std::out_of_range& e) {
14099       {
14100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14101       };
14102     } catch (std::exception& e) {
14103       {
14104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14105       };
14106     } catch (...) {
14107       {
14108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14109       };
14110     }
14111   }
14112   jresult = result;
14113   return jresult;
14114 }
14115
14116
14117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14118   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14119   char *arg2 = (char *) 0 ;
14120   Dali::Property::Value *arg3 = 0 ;
14121
14122   arg1 = (Dali::Property::Map *)jarg1;
14123   arg2 = (char *)jarg2;
14124   arg3 = (Dali::Property::Value *)jarg3;
14125   if (!arg3) {
14126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14127     return ;
14128   }
14129   {
14130     try {
14131       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14132     } catch (std::out_of_range& e) {
14133       {
14134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14135       };
14136     } catch (std::exception& e) {
14137       {
14138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14139       };
14140     } catch (...) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14143       };
14144     }
14145   }
14146 }
14147
14148
14149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14150   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14151   Dali::Property::Index arg2 ;
14152   Dali::Property::Value *arg3 = 0 ;
14153
14154   arg1 = (Dali::Property::Map *)jarg1;
14155   arg2 = (Dali::Property::Index)jarg2;
14156   arg3 = (Dali::Property::Value *)jarg3;
14157   if (!arg3) {
14158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14159     return ;
14160   }
14161   {
14162     try {
14163       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14164     } catch (std::out_of_range& e) {
14165       {
14166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14167       };
14168     } catch (std::exception& e) {
14169       {
14170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14171       };
14172     } catch (...) {
14173       {
14174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14175       };
14176     }
14177   }
14178 }
14179
14180
14181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14182   void * jresult ;
14183   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14184   char *arg2 = (char *) 0 ;
14185   Dali::Property::Value *arg3 = 0 ;
14186   Dali::Property::Map *result = 0 ;
14187
14188   arg1 = (Dali::Property::Map *)jarg1;
14189   arg2 = (char *)jarg2;
14190   arg3 = (Dali::Property::Value *)jarg3;
14191   if (!arg3) {
14192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14193     return 0;
14194   }
14195   {
14196     try {
14197       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14198     } catch (std::out_of_range& e) {
14199       {
14200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14201       };
14202     } catch (std::exception& e) {
14203       {
14204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14205       };
14206     } catch (...) {
14207       {
14208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14209       };
14210     }
14211   }
14212   jresult = (void *)result;
14213   return jresult;
14214 }
14215
14216
14217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14218   void * jresult ;
14219   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14220   Dali::Property::Index arg2 ;
14221   Dali::Property::Value *arg3 = 0 ;
14222   Dali::Property::Map *result = 0 ;
14223
14224   arg1 = (Dali::Property::Map *)jarg1;
14225   arg2 = (Dali::Property::Index)jarg2;
14226   arg3 = (Dali::Property::Value *)jarg3;
14227   if (!arg3) {
14228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14229     return 0;
14230   }
14231   {
14232     try {
14233       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14234     } catch (std::out_of_range& e) {
14235       {
14236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14237       };
14238     } catch (std::exception& e) {
14239       {
14240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14241       };
14242     } catch (...) {
14243       {
14244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14245       };
14246     }
14247   }
14248   jresult = (void *)result;
14249   return jresult;
14250 }
14251
14252
14253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14254   void * jresult ;
14255   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14256   Dali::Property::Map::SizeType arg2 ;
14257   Dali::Property::Value *result = 0 ;
14258
14259   arg1 = (Dali::Property::Map *)jarg1;
14260   arg2 = (Dali::Property::Map::SizeType)jarg2;
14261   {
14262     try {
14263       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14264     } catch (std::out_of_range& e) {
14265       {
14266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14267       };
14268     } catch (std::exception& e) {
14269       {
14270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14271       };
14272     } catch (...) {
14273       {
14274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14275       };
14276     }
14277   }
14278   jresult = (void *)result;
14279   return jresult;
14280 }
14281
14282
14283 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14284   char * jresult ;
14285   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14286   Dali::Property::Map::SizeType arg2 ;
14287   std::string *result = 0 ;
14288
14289   arg1 = (Dali::Property::Map *)jarg1;
14290   arg2 = (Dali::Property::Map::SizeType)jarg2;
14291   {
14292     try {
14293       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14294     } catch (std::out_of_range& e) {
14295       {
14296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14297       };
14298     } catch (std::exception& e) {
14299       {
14300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14301       };
14302     } catch (...) {
14303       {
14304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14305       };
14306     }
14307   }
14308   jresult = SWIG_csharp_string_callback(result->c_str());
14309   return jresult;
14310 }
14311
14312
14313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14314   void * jresult ;
14315   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14316   Dali::Property::Map::SizeType arg2 ;
14317   SwigValueWrapper< Dali::Property::Key > result;
14318
14319   arg1 = (Dali::Property::Map *)jarg1;
14320   arg2 = (Dali::Property::Map::SizeType)jarg2;
14321   {
14322     try {
14323       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14324     } catch (std::out_of_range& e) {
14325       {
14326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14327       };
14328     } catch (std::exception& e) {
14329       {
14330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14331       };
14332     } catch (...) {
14333       {
14334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14335       };
14336     }
14337   }
14338   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14339   return jresult;
14340 }
14341
14342
14343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14344   void * jresult ;
14345   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14346   Dali::Property::Map::SizeType arg2 ;
14347   StringValuePair *result = 0 ;
14348
14349   arg1 = (Dali::Property::Map *)jarg1;
14350   arg2 = (Dali::Property::Map::SizeType)jarg2;
14351   {
14352     try {
14353       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14354     } catch (std::out_of_range& e) {
14355       {
14356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14357       };
14358     } catch (std::exception& e) {
14359       {
14360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14361       };
14362     } catch (...) {
14363       {
14364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14365       };
14366     }
14367   }
14368   jresult = (void *)result;
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14374   void * jresult ;
14375   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14376   char *arg2 = (char *) 0 ;
14377   Dali::Property::Value *result = 0 ;
14378
14379   arg1 = (Dali::Property::Map *)jarg1;
14380   arg2 = (char *)jarg2;
14381   {
14382     try {
14383       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (...) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14395       };
14396     }
14397   }
14398   jresult = (void *)result;
14399   return jresult;
14400 }
14401
14402
14403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14404   void * jresult ;
14405   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14406   Dali::Property::Index arg2 ;
14407   Dali::Property::Value *result = 0 ;
14408
14409   arg1 = (Dali::Property::Map *)jarg1;
14410   arg2 = (Dali::Property::Index)jarg2;
14411   {
14412     try {
14413       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14414     } catch (std::out_of_range& e) {
14415       {
14416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14417       };
14418     } catch (std::exception& e) {
14419       {
14420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (...) {
14423       {
14424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14425       };
14426     }
14427   }
14428   jresult = (void *)result;
14429   return jresult;
14430 }
14431
14432
14433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14434   void * jresult ;
14435   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14436   Dali::Property::Index arg2 ;
14437   std::string *arg3 = 0 ;
14438   Dali::Property::Value *result = 0 ;
14439
14440   arg1 = (Dali::Property::Map *)jarg1;
14441   arg2 = (Dali::Property::Index)jarg2;
14442   if (!jarg3) {
14443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14444     return 0;
14445   }
14446   std::string arg3_str(jarg3);
14447   arg3 = &arg3_str;
14448   {
14449     try {
14450       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14451     } catch (std::out_of_range& e) {
14452       {
14453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14454       };
14455     } catch (std::exception& e) {
14456       {
14457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14458       };
14459     } catch (...) {
14460       {
14461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14462       };
14463     }
14464   }
14465   jresult = (void *)result;
14466
14467   //argout typemap for const std::string&
14468
14469   return jresult;
14470 }
14471
14472
14473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14474   void * jresult ;
14475   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14476   std::string *arg2 = 0 ;
14477   Dali::Property::Type arg3 ;
14478   Dali::Property::Value *result = 0 ;
14479
14480   arg1 = (Dali::Property::Map *)jarg1;
14481   if (!jarg2) {
14482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14483     return 0;
14484   }
14485   std::string arg2_str(jarg2);
14486   arg2 = &arg2_str;
14487   arg3 = (Dali::Property::Type)jarg3;
14488   {
14489     try {
14490       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14491     } catch (std::out_of_range& e) {
14492       {
14493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (std::exception& e) {
14496       {
14497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (...) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14502       };
14503     }
14504   }
14505   jresult = (void *)result;
14506
14507   //argout typemap for const std::string&
14508
14509   return jresult;
14510 }
14511
14512
14513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14514   void * jresult ;
14515   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14516   Dali::Property::Index arg2 ;
14517   Dali::Property::Type arg3 ;
14518   Dali::Property::Value *result = 0 ;
14519
14520   arg1 = (Dali::Property::Map *)jarg1;
14521   arg2 = (Dali::Property::Index)jarg2;
14522   arg3 = (Dali::Property::Type)jarg3;
14523   {
14524     try {
14525       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14526     } catch (std::out_of_range& e) {
14527       {
14528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (std::exception& e) {
14531       {
14532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14533       };
14534     } catch (...) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14537       };
14538     }
14539   }
14540   jresult = (void *)result;
14541   return jresult;
14542 }
14543
14544
14545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14546   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14547
14548   arg1 = (Dali::Property::Map *)jarg1;
14549   {
14550     try {
14551       (arg1)->Clear();
14552     } catch (std::out_of_range& e) {
14553       {
14554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14555       };
14556     } catch (std::exception& e) {
14557       {
14558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14559       };
14560     } catch (...) {
14561       {
14562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14563       };
14564     }
14565   }
14566 }
14567
14568
14569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14570   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14571   Dali::Property::Map *arg2 = 0 ;
14572
14573   arg1 = (Dali::Property::Map *)jarg1;
14574   arg2 = (Dali::Property::Map *)jarg2;
14575   if (!arg2) {
14576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14577     return ;
14578   }
14579   {
14580     try {
14581       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14582     } catch (std::out_of_range& e) {
14583       {
14584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14585       };
14586     } catch (std::exception& e) {
14587       {
14588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14589       };
14590     } catch (...) {
14591       {
14592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14593       };
14594     }
14595   }
14596 }
14597
14598
14599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14600   void * jresult ;
14601   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14602   std::string *arg2 = 0 ;
14603   Dali::Property::Value *result = 0 ;
14604
14605   arg1 = (Dali::Property::Map *)jarg1;
14606   if (!jarg2) {
14607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14608     return 0;
14609   }
14610   std::string arg2_str(jarg2);
14611   arg2 = &arg2_str;
14612   {
14613     try {
14614       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14615     } catch (std::out_of_range& e) {
14616       {
14617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14618       };
14619     } catch (std::exception& e) {
14620       {
14621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14622       };
14623     } catch (...) {
14624       {
14625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14626       };
14627     }
14628   }
14629   jresult = (void *)result;
14630
14631   //argout typemap for const std::string&
14632
14633   return jresult;
14634 }
14635
14636
14637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14638   void * jresult ;
14639   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14640   Dali::Property::Index arg2 ;
14641   Dali::Property::Value *result = 0 ;
14642
14643   arg1 = (Dali::Property::Map *)jarg1;
14644   arg2 = (Dali::Property::Index)jarg2;
14645   {
14646     try {
14647       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14648     } catch (std::out_of_range& e) {
14649       {
14650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14651       };
14652     } catch (std::exception& e) {
14653       {
14654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14655       };
14656     } catch (...) {
14657       {
14658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14659       };
14660     }
14661   }
14662   jresult = (void *)result;
14663   return jresult;
14664 }
14665
14666
14667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14668   void * jresult ;
14669   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14670   Dali::Property::Map *arg2 = 0 ;
14671   Dali::Property::Map *result = 0 ;
14672
14673   arg1 = (Dali::Property::Map *)jarg1;
14674   arg2 = (Dali::Property::Map *)jarg2;
14675   if (!arg2) {
14676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14677     return 0;
14678   }
14679   {
14680     try {
14681       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14682     } catch (std::out_of_range& e) {
14683       {
14684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14685       };
14686     } catch (std::exception& e) {
14687       {
14688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14689       };
14690     } catch (...) {
14691       {
14692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14693       };
14694     }
14695   }
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14702   void * jresult ;
14703   Dali::Property::Value *result = 0 ;
14704
14705   {
14706     try {
14707       result = (Dali::Property::Value *)new Dali::Property::Value();
14708     } catch (std::out_of_range& e) {
14709       {
14710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14711       };
14712     } catch (std::exception& e) {
14713       {
14714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14715       };
14716     } catch (...) {
14717       {
14718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14719       };
14720     }
14721   }
14722   jresult = (void *)result;
14723   return jresult;
14724 }
14725
14726
14727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14728   void * jresult ;
14729   bool arg1 ;
14730   Dali::Property::Value *result = 0 ;
14731
14732   arg1 = jarg1 ? true : false;
14733   {
14734     try {
14735       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14736     } catch (std::out_of_range& e) {
14737       {
14738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14739       };
14740     } catch (std::exception& e) {
14741       {
14742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14743       };
14744     } catch (...) {
14745       {
14746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14747       };
14748     }
14749   }
14750   jresult = (void *)result;
14751   return jresult;
14752 }
14753
14754
14755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14756   void * jresult ;
14757   int arg1 ;
14758   Dali::Property::Value *result = 0 ;
14759
14760   arg1 = (int)jarg1;
14761   {
14762     try {
14763       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14764     } catch (std::out_of_range& e) {
14765       {
14766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14767       };
14768     } catch (std::exception& e) {
14769       {
14770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (...) {
14773       {
14774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14775       };
14776     }
14777   }
14778   jresult = (void *)result;
14779   return jresult;
14780 }
14781
14782
14783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14784   void * jresult ;
14785   float arg1 ;
14786   Dali::Property::Value *result = 0 ;
14787
14788   arg1 = (float)jarg1;
14789   {
14790     try {
14791       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14792     } catch (std::out_of_range& e) {
14793       {
14794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14795       };
14796     } catch (std::exception& e) {
14797       {
14798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14799       };
14800     } catch (...) {
14801       {
14802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14803       };
14804     }
14805   }
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14812   void * jresult ;
14813   Dali::Vector2 *arg1 = 0 ;
14814   Dali::Property::Value *result = 0 ;
14815
14816   arg1 = (Dali::Vector2 *)jarg1;
14817   if (!arg1) {
14818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14819     return 0;
14820   }
14821   {
14822     try {
14823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14824     } catch (std::out_of_range& e) {
14825       {
14826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14827       };
14828     } catch (std::exception& e) {
14829       {
14830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14831       };
14832     } catch (...) {
14833       {
14834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14835       };
14836     }
14837   }
14838   jresult = (void *)result;
14839   return jresult;
14840 }
14841
14842
14843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14844   void * jresult ;
14845   Dali::Vector3 *arg1 = 0 ;
14846   Dali::Property::Value *result = 0 ;
14847
14848   arg1 = (Dali::Vector3 *)jarg1;
14849   if (!arg1) {
14850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14851     return 0;
14852   }
14853   {
14854     try {
14855       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*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_6(void * jarg1) {
14876   void * jresult ;
14877   Dali::Vector4 *arg1 = 0 ;
14878   Dali::Property::Value *result = 0 ;
14879
14880   arg1 = (Dali::Vector4 *)jarg1;
14881   if (!arg1) {
14882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14883     return 0;
14884   }
14885   {
14886     try {
14887       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 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_7(void * jarg1) {
14908   void * jresult ;
14909   Dali::Matrix3 *arg1 = 0 ;
14910   Dali::Property::Value *result = 0 ;
14911
14912   arg1 = (Dali::Matrix3 *)jarg1;
14913   if (!arg1) {
14914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14915     return 0;
14916   }
14917   {
14918     try {
14919       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 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_8(void * jarg1) {
14940   void * jresult ;
14941   Dali::Matrix *arg1 = 0 ;
14942   Dali::Property::Value *result = 0 ;
14943
14944   arg1 = (Dali::Matrix *)jarg1;
14945   if (!arg1) {
14946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14947     return 0;
14948   }
14949   {
14950     try {
14951       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix 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_9(void * jarg1) {
14972   void * jresult ;
14973   Dali::Rect< int > *arg1 = 0 ;
14974   Dali::Property::Value *result = 0 ;
14975
14976   arg1 = (Dali::Rect< int > *)jarg1;
14977   if (!arg1) {
14978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14979     return 0;
14980   }
14981   {
14982     try {
14983       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > 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_10(void * jarg1) {
15004   void * jresult ;
15005   Dali::AngleAxis *arg1 = 0 ;
15006   Dali::Property::Value *result = 0 ;
15007
15008   arg1 = (Dali::AngleAxis *)jarg1;
15009   if (!arg1) {
15010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15011     return 0;
15012   }
15013   {
15014     try {
15015       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis 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_11(void * jarg1) {
15036   void * jresult ;
15037   Dali::Quaternion *arg1 = 0 ;
15038   Dali::Property::Value *result = 0 ;
15039
15040   arg1 = (Dali::Quaternion *)jarg1;
15041   if (!arg1) {
15042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15043     return 0;
15044   }
15045   {
15046     try {
15047       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion 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_12(char * jarg1) {
15068   void * jresult ;
15069   std::string *arg1 = 0 ;
15070   Dali::Property::Value *result = 0 ;
15071
15072   if (!jarg1) {
15073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15074     return 0;
15075   }
15076   std::string arg1_str(jarg1);
15077   arg1 = &arg1_str;
15078   {
15079     try {
15080       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15081     } catch (std::out_of_range& e) {
15082       {
15083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15084       };
15085     } catch (std::exception& e) {
15086       {
15087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15088       };
15089     } catch (...) {
15090       {
15091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15092       };
15093     }
15094   }
15095   jresult = (void *)result;
15096
15097   //argout typemap for const std::string&
15098
15099   return jresult;
15100 }
15101
15102
15103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15104   void * jresult ;
15105   Dali::Property::Array *arg1 = 0 ;
15106   Dali::Property::Value *result = 0 ;
15107
15108   arg1 = (Dali::Property::Array *)jarg1;
15109   if (!arg1) {
15110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15111     return 0;
15112   }
15113   {
15114     try {
15115       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15116     } catch (std::out_of_range& e) {
15117       {
15118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15119       };
15120     } catch (std::exception& e) {
15121       {
15122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15123       };
15124     } catch (...) {
15125       {
15126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15127       };
15128     }
15129   }
15130   jresult = (void *)result;
15131   return jresult;
15132 }
15133
15134
15135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15136   void * jresult ;
15137   Dali::Property::Map *arg1 = 0 ;
15138   Dali::Property::Value *result = 0 ;
15139
15140   arg1 = (Dali::Property::Map *)jarg1;
15141   if (!arg1) {
15142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15143     return 0;
15144   }
15145   {
15146     try {
15147       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15148     } catch (std::out_of_range& e) {
15149       {
15150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15151       };
15152     } catch (std::exception& e) {
15153       {
15154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15155       };
15156     } catch (...) {
15157       {
15158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15159       };
15160     }
15161   }
15162   jresult = (void *)result;
15163   return jresult;
15164 }
15165
15166
15167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15168   void * jresult ;
15169   Dali::Property::Type arg1 ;
15170   Dali::Property::Value *result = 0 ;
15171
15172   arg1 = (Dali::Property::Type)jarg1;
15173   {
15174     try {
15175       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15176     } catch (std::out_of_range& e) {
15177       {
15178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15179       };
15180     } catch (std::exception& e) {
15181       {
15182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15183       };
15184     } catch (...) {
15185       {
15186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15187       };
15188     }
15189   }
15190   jresult = (void *)result;
15191   return jresult;
15192 }
15193
15194
15195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15196   void * jresult ;
15197   Dali::Property::Value *arg1 = 0 ;
15198   Dali::Property::Value *result = 0 ;
15199
15200   arg1 = (Dali::Property::Value *)jarg1;
15201   if (!arg1) {
15202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15203     return 0;
15204   }
15205   {
15206     try {
15207       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15208     } catch (std::out_of_range& e) {
15209       {
15210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15211       };
15212     } catch (std::exception& e) {
15213       {
15214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15215       };
15216     } catch (...) {
15217       {
15218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15219       };
15220     }
15221   }
15222   jresult = (void *)result;
15223   return jresult;
15224 }
15225
15226
15227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15228   void * jresult ;
15229   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15230   Dali::Property::Value *arg2 = 0 ;
15231   Dali::Property::Value *result = 0 ;
15232
15233   arg1 = (Dali::Property::Value *)jarg1;
15234   arg2 = (Dali::Property::Value *)jarg2;
15235   if (!arg2) {
15236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15237     return 0;
15238   }
15239   {
15240     try {
15241       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15242     } catch (std::out_of_range& e) {
15243       {
15244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15245       };
15246     } catch (std::exception& e) {
15247       {
15248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15249       };
15250     } catch (...) {
15251       {
15252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15253       };
15254     }
15255   }
15256   jresult = (void *)result;
15257   return jresult;
15258 }
15259
15260
15261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15262   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15263
15264   arg1 = (Dali::Property::Value *)jarg1;
15265   {
15266     try {
15267       delete arg1;
15268     } catch (std::out_of_range& e) {
15269       {
15270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15271       };
15272     } catch (std::exception& e) {
15273       {
15274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15275       };
15276     } catch (...) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15279       };
15280     }
15281   }
15282 }
15283
15284
15285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15286   int jresult ;
15287   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15288   Dali::Property::Type result;
15289
15290   arg1 = (Dali::Property::Value *)jarg1;
15291   {
15292     try {
15293       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15294     } catch (std::out_of_range& e) {
15295       {
15296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15297       };
15298     } catch (std::exception& e) {
15299       {
15300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15301       };
15302     } catch (...) {
15303       {
15304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15305       };
15306     }
15307   }
15308   jresult = (int)result;
15309   return jresult;
15310 }
15311
15312
15313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15314   unsigned int jresult ;
15315   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15316   bool *arg2 = 0 ;
15317   bool result;
15318
15319   arg1 = (Dali::Property::Value *)jarg1;
15320   arg2 = (bool *)jarg2;
15321   {
15322     try {
15323       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15324     } catch (std::out_of_range& e) {
15325       {
15326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15327       };
15328     } catch (std::exception& e) {
15329       {
15330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (...) {
15333       {
15334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15335       };
15336     }
15337   }
15338   jresult = result;
15339   return jresult;
15340 }
15341
15342
15343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15344   unsigned int jresult ;
15345   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15346   float *arg2 = 0 ;
15347   bool result;
15348
15349   arg1 = (Dali::Property::Value *)jarg1;
15350   arg2 = (float *)jarg2;
15351   {
15352     try {
15353       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15354     } catch (std::out_of_range& e) {
15355       {
15356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15357       };
15358     } catch (std::exception& e) {
15359       {
15360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15361       };
15362     } catch (...) {
15363       {
15364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15365       };
15366     }
15367   }
15368   jresult = result;
15369   return jresult;
15370 }
15371
15372
15373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15374   unsigned int jresult ;
15375   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15376   int *arg2 = 0 ;
15377   bool result;
15378
15379   arg1 = (Dali::Property::Value *)jarg1;
15380   arg2 = (int *)jarg2;
15381   {
15382     try {
15383       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15384     } catch (std::out_of_range& e) {
15385       {
15386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15387       };
15388     } catch (std::exception& e) {
15389       {
15390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15391       };
15392     } catch (...) {
15393       {
15394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15395       };
15396     }
15397   }
15398   jresult = result;
15399   return jresult;
15400 }
15401
15402
15403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15404   unsigned int jresult ;
15405   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15406   Dali::Rect< int > *arg2 = 0 ;
15407   bool result;
15408
15409   arg1 = (Dali::Property::Value *)jarg1;
15410   arg2 = (Dali::Rect< int > *)jarg2;
15411   if (!arg2) {
15412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15413     return 0;
15414   }
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_5(void * jarg1, void * jarg2) {
15438   unsigned int jresult ;
15439   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15440   Dali::Vector2 *arg2 = 0 ;
15441   bool result;
15442
15443   arg1 = (Dali::Property::Value *)jarg1;
15444   arg2 = (Dali::Vector2 *)jarg2;
15445   if (!arg2) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15447     return 0;
15448   }
15449   {
15450     try {
15451       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15452     } catch (std::out_of_range& e) {
15453       {
15454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15455       };
15456     } catch (std::exception& e) {
15457       {
15458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15459       };
15460     } catch (...) {
15461       {
15462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15463       };
15464     }
15465   }
15466   jresult = result;
15467   return jresult;
15468 }
15469
15470
15471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15472   unsigned int jresult ;
15473   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15474   Dali::Vector3 *arg2 = 0 ;
15475   bool result;
15476
15477   arg1 = (Dali::Property::Value *)jarg1;
15478   arg2 = (Dali::Vector3 *)jarg2;
15479   if (!arg2) {
15480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15481     return 0;
15482   }
15483   {
15484     try {
15485       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15486     } catch (std::out_of_range& e) {
15487       {
15488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15489       };
15490     } catch (std::exception& e) {
15491       {
15492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15493       };
15494     } catch (...) {
15495       {
15496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15497       };
15498     }
15499   }
15500   jresult = result;
15501   return jresult;
15502 }
15503
15504
15505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15506   unsigned int jresult ;
15507   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15508   Dali::Vector4 *arg2 = 0 ;
15509   bool result;
15510
15511   arg1 = (Dali::Property::Value *)jarg1;
15512   arg2 = (Dali::Vector4 *)jarg2;
15513   if (!arg2) {
15514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15515     return 0;
15516   }
15517   {
15518     try {
15519       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15520     } catch (std::out_of_range& e) {
15521       {
15522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (std::exception& e) {
15525       {
15526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15527       };
15528     } catch (...) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15531       };
15532     }
15533   }
15534   jresult = result;
15535   return jresult;
15536 }
15537
15538
15539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15540   unsigned int jresult ;
15541   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15542   Dali::Matrix3 *arg2 = 0 ;
15543   bool result;
15544
15545   arg1 = (Dali::Property::Value *)jarg1;
15546   arg2 = (Dali::Matrix3 *)jarg2;
15547   if (!arg2) {
15548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15549     return 0;
15550   }
15551   {
15552     try {
15553       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15554     } catch (std::out_of_range& e) {
15555       {
15556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (std::exception& e) {
15559       {
15560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15561       };
15562     } catch (...) {
15563       {
15564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15565       };
15566     }
15567   }
15568   jresult = result;
15569   return jresult;
15570 }
15571
15572
15573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15574   unsigned int jresult ;
15575   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15576   Dali::Matrix *arg2 = 0 ;
15577   bool result;
15578
15579   arg1 = (Dali::Property::Value *)jarg1;
15580   arg2 = (Dali::Matrix *)jarg2;
15581   if (!arg2) {
15582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15583     return 0;
15584   }
15585   {
15586     try {
15587       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15588     } catch (std::out_of_range& e) {
15589       {
15590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15591       };
15592     } catch (std::exception& e) {
15593       {
15594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15595       };
15596     } catch (...) {
15597       {
15598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15599       };
15600     }
15601   }
15602   jresult = result;
15603   return jresult;
15604 }
15605
15606
15607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15608   unsigned int jresult ;
15609   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15610   Dali::AngleAxis *arg2 = 0 ;
15611   bool result;
15612
15613   arg1 = (Dali::Property::Value *)jarg1;
15614   arg2 = (Dali::AngleAxis *)jarg2;
15615   if (!arg2) {
15616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15617     return 0;
15618   }
15619   {
15620     try {
15621       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15622     } catch (std::out_of_range& e) {
15623       {
15624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15625       };
15626     } catch (std::exception& e) {
15627       {
15628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15629       };
15630     } catch (...) {
15631       {
15632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15633       };
15634     }
15635   }
15636   jresult = result;
15637   return jresult;
15638 }
15639
15640
15641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15642   unsigned int jresult ;
15643   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15644   Dali::Quaternion *arg2 = 0 ;
15645   bool result;
15646
15647   arg1 = (Dali::Property::Value *)jarg1;
15648   arg2 = (Dali::Quaternion *)jarg2;
15649   if (!arg2) {
15650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15651     return 0;
15652   }
15653   {
15654     try {
15655       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15656     } catch (std::out_of_range& e) {
15657       {
15658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15659       };
15660     } catch (std::exception& e) {
15661       {
15662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15663       };
15664     } catch (...) {
15665       {
15666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15667       };
15668     }
15669   }
15670   jresult = result;
15671   return jresult;
15672 }
15673
15674
15675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15676   unsigned int jresult ;
15677   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15678   std::string *arg2 = 0 ;
15679   bool result;
15680
15681   arg1 = (Dali::Property::Value *)jarg1;
15682
15683   //typemap in
15684   std::string temp;
15685   arg2 = &temp;
15686
15687   {
15688     try {
15689       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15690     } catch (std::out_of_range& e) {
15691       {
15692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15693       };
15694     } catch (std::exception& e) {
15695       {
15696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15697       };
15698     } catch (...) {
15699       {
15700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15701       };
15702     }
15703   }
15704   jresult = result;
15705
15706   //Typemap argout in c++ file.
15707   //This will convert c++ string to c# string
15708   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15709
15710   return jresult;
15711 }
15712
15713
15714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15715   unsigned int jresult ;
15716   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15717   Dali::Property::Array *arg2 = 0 ;
15718   bool result;
15719
15720   arg1 = (Dali::Property::Value *)jarg1;
15721   arg2 = (Dali::Property::Array *)jarg2;
15722   if (!arg2) {
15723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15724     return 0;
15725   }
15726   {
15727     try {
15728       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15729     } catch (std::out_of_range& e) {
15730       {
15731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15732       };
15733     } catch (std::exception& e) {
15734       {
15735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15736       };
15737     } catch (...) {
15738       {
15739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15740       };
15741     }
15742   }
15743   jresult = result;
15744   return jresult;
15745 }
15746
15747
15748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15749   unsigned int jresult ;
15750   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15751   Dali::Property::Map *arg2 = 0 ;
15752   bool result;
15753
15754   arg1 = (Dali::Property::Value *)jarg1;
15755   arg2 = (Dali::Property::Map *)jarg2;
15756   if (!arg2) {
15757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15758     return 0;
15759   }
15760   {
15761     try {
15762       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15763     } catch (std::out_of_range& e) {
15764       {
15765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15766       };
15767     } catch (std::exception& e) {
15768       {
15769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15770       };
15771     } catch (...) {
15772       {
15773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15774       };
15775     }
15776   }
15777   jresult = result;
15778   return jresult;
15779 }
15780
15781
15782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15783   void * jresult ;
15784   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15785   Dali::Property::Array *result = 0 ;
15786
15787   arg1 = (Dali::Property::Value *)jarg1;
15788   {
15789     try {
15790       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15791     } catch (std::out_of_range& e) {
15792       {
15793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15794       };
15795     } catch (std::exception& e) {
15796       {
15797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15798       };
15799     } catch (...) {
15800       {
15801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15802       };
15803     }
15804   }
15805   jresult = (void *)result;
15806   return jresult;
15807 }
15808
15809
15810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15811   void * jresult ;
15812   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15813   Dali::Property::Map *result = 0 ;
15814
15815   arg1 = (Dali::Property::Value *)jarg1;
15816   {
15817     try {
15818       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15819     } catch (std::out_of_range& e) {
15820       {
15821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15822       };
15823     } catch (std::exception& e) {
15824       {
15825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15826       };
15827     } catch (...) {
15828       {
15829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15830       };
15831     }
15832   }
15833   jresult = (void *)result;
15834   return jresult;
15835 }
15836
15837
15838 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15839   char * jresult ;
15840   Dali::Property::Type arg1 ;
15841   char *result = 0 ;
15842
15843   arg1 = (Dali::Property::Type)jarg1;
15844   {
15845     try {
15846       result = (char *)Dali::PropertyTypes::GetName(arg1);
15847     } catch (std::out_of_range& e) {
15848       {
15849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15850       };
15851     } catch (std::exception& e) {
15852       {
15853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (...) {
15856       {
15857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15858       };
15859     }
15860   }
15861   jresult = SWIG_csharp_string_callback((const char *)result);
15862   return jresult;
15863 }
15864
15865
15866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15867   unsigned int jresult ;
15868   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15869   std::string *arg2 = 0 ;
15870   Dali::Property::Map *arg3 = 0 ;
15871   bool result;
15872
15873   arg1 = (Dali::BaseObject *)jarg1;
15874   if (!jarg2) {
15875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15876     return 0;
15877   }
15878   std::string arg2_str(jarg2);
15879   arg2 = &arg2_str;
15880   arg3 = (Dali::Property::Map *)jarg3;
15881   if (!arg3) {
15882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15883     return 0;
15884   }
15885   {
15886     try {
15887       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15888     } catch (std::out_of_range& e) {
15889       {
15890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15891       };
15892     } catch (std::exception& e) {
15893       {
15894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15895       };
15896     } catch (...) {
15897       {
15898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15899       };
15900     }
15901   }
15902   jresult = result;
15903
15904   //argout typemap for const std::string&
15905
15906   return jresult;
15907 }
15908
15909
15910 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15911   char * jresult ;
15912   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15913   std::string *result = 0 ;
15914
15915   arg1 = (Dali::BaseObject *)jarg1;
15916   {
15917     try {
15918       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15919     } catch (std::out_of_range& e) {
15920       {
15921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15922       };
15923     } catch (std::exception& e) {
15924       {
15925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15926       };
15927     } catch (...) {
15928       {
15929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15930       };
15931     }
15932   }
15933   jresult = SWIG_csharp_string_callback(result->c_str());
15934   return jresult;
15935 }
15936
15937
15938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15939   unsigned int jresult ;
15940   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15941   Dali::TypeInfo *arg2 = 0 ;
15942   bool result;
15943
15944   arg1 = (Dali::BaseObject *)jarg1;
15945   arg2 = (Dali::TypeInfo *)jarg2;
15946   if (!arg2) {
15947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15948     return 0;
15949   }
15950   {
15951     try {
15952       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15953     } catch (std::out_of_range& e) {
15954       {
15955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (std::exception& e) {
15958       {
15959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15960       };
15961     } catch (...) {
15962       {
15963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15964       };
15965     }
15966   }
15967   jresult = result;
15968   return jresult;
15969 }
15970
15971
15972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15973   unsigned int jresult ;
15974   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15975   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15976   std::string *arg3 = 0 ;
15977   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15978   bool result;
15979
15980   arg1 = (Dali::BaseObject *)jarg1;
15981   arg2 = (ConnectionTrackerInterface *)jarg2;
15982   if (!jarg3) {
15983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15984     return 0;
15985   }
15986   std::string arg3_str(jarg3);
15987   arg3 = &arg3_str;
15988   arg4 = (FunctorDelegate *)jarg4;
15989   {
15990     try {
15991       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15992     } catch (std::out_of_range& e) {
15993       {
15994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15995       };
15996     } catch (std::exception& e) {
15997       {
15998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16003       };
16004     }
16005   }
16006   jresult = result;
16007
16008   //argout typemap for const std::string&
16009
16010   return jresult;
16011 }
16012
16013
16014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16015   void * jresult ;
16016   Dali::BaseHandle *arg1 = 0 ;
16017   Dali::BaseObject *result = 0 ;
16018
16019   arg1 = (Dali::BaseHandle *)jarg1;
16020   if (!arg1) {
16021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16022     return 0;
16023   }
16024   {
16025     try {
16026       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16027     } catch (std::out_of_range& e) {
16028       {
16029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16030       };
16031     } catch (std::exception& e) {
16032       {
16033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16034       };
16035     } catch (...) {
16036       {
16037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16038       };
16039     }
16040   }
16041   jresult = (void *)result;
16042   return jresult;
16043 }
16044
16045
16046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16047   void * jresult ;
16048   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16049   Dali::BaseHandle *result = 0 ;
16050
16051   arg1 = (Dali::BaseObject *)jarg1;
16052   {
16053     try {
16054       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16055     } catch (std::out_of_range& e) {
16056       {
16057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16058       };
16059     } catch (std::exception& e) {
16060       {
16061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16062       };
16063     } catch (...) {
16064       {
16065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16066       };
16067     }
16068   }
16069   jresult = (void *)result;
16070   return jresult;
16071 }
16072
16073
16074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16075   void * jresult ;
16076   Dali::BaseHandle *result = 0 ;
16077
16078   {
16079     try {
16080       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16081     } catch (std::out_of_range& e) {
16082       {
16083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16084       };
16085     } catch (std::exception& e) {
16086       {
16087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16088       };
16089     } catch (...) {
16090       {
16091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16092       };
16093     }
16094   }
16095   jresult = (void *)result;
16096   return jresult;
16097 }
16098
16099
16100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16101   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16102
16103   arg1 = (Dali::BaseHandle *)jarg1;
16104   {
16105     try {
16106       delete arg1;
16107     } catch (std::out_of_range& e) {
16108       {
16109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16110       };
16111     } catch (std::exception& e) {
16112       {
16113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16118       };
16119     }
16120   }
16121 }
16122
16123
16124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16125   void * jresult ;
16126   Dali::BaseHandle *arg1 = 0 ;
16127   Dali::BaseHandle *result = 0 ;
16128
16129   arg1 = (Dali::BaseHandle *)jarg1;
16130   if (!arg1) {
16131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16132     return 0;
16133   }
16134   {
16135     try {
16136       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (...) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16148       };
16149     }
16150   }
16151   jresult = (void *)result;
16152   return jresult;
16153 }
16154
16155
16156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16157   void * jresult ;
16158   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16159   Dali::BaseHandle *arg2 = 0 ;
16160   Dali::BaseHandle *result = 0 ;
16161
16162   arg1 = (Dali::BaseHandle *)jarg1;
16163   arg2 = (Dali::BaseHandle *)jarg2;
16164   if (!arg2) {
16165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16166     return 0;
16167   }
16168   {
16169     try {
16170       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16171     } catch (std::out_of_range& e) {
16172       {
16173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16174       };
16175     } catch (std::exception& e) {
16176       {
16177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (...) {
16180       {
16181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16182       };
16183     }
16184   }
16185   jresult = (void *)result;
16186   return jresult;
16187 }
16188
16189
16190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16191   unsigned int jresult ;
16192   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16193   std::string *arg2 = 0 ;
16194   Dali::Property::Map *arg3 = 0 ;
16195   bool result;
16196
16197   arg1 = (Dali::BaseHandle *)jarg1;
16198   if (!jarg2) {
16199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16200     return 0;
16201   }
16202   std::string arg2_str(jarg2);
16203   arg2 = &arg2_str;
16204   arg3 = (Dali::Property::Map *)jarg3;
16205   if (!arg3) {
16206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16207     return 0;
16208   }
16209   {
16210     try {
16211       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16212     } catch (std::out_of_range& e) {
16213       {
16214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (std::exception& e) {
16217       {
16218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16219       };
16220     } catch (...) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16223       };
16224     }
16225   }
16226   jresult = result;
16227
16228   //argout typemap for const std::string&
16229
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16235   char * jresult ;
16236   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16237   std::string *result = 0 ;
16238
16239   arg1 = (Dali::BaseHandle *)jarg1;
16240   {
16241     try {
16242       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16243     } catch (std::out_of_range& e) {
16244       {
16245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (std::exception& e) {
16248       {
16249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (...) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16254       };
16255     }
16256   }
16257   jresult = SWIG_csharp_string_callback(result->c_str());
16258   return jresult;
16259 }
16260
16261
16262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16263   unsigned int jresult ;
16264   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16265   Dali::TypeInfo *arg2 = 0 ;
16266   bool result;
16267
16268   arg1 = (Dali::BaseHandle *)jarg1;
16269   arg2 = (Dali::TypeInfo *)jarg2;
16270   if (!arg2) {
16271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16272     return 0;
16273   }
16274   {
16275     try {
16276       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16277     } catch (std::out_of_range& e) {
16278       {
16279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (std::exception& e) {
16282       {
16283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16284       };
16285     } catch (...) {
16286       {
16287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16288       };
16289     }
16290   }
16291   jresult = result;
16292   return jresult;
16293 }
16294
16295
16296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16297   void * jresult ;
16298   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16299   Dali::BaseObject *result = 0 ;
16300
16301   arg1 = (Dali::BaseHandle *)jarg1;
16302   {
16303     try {
16304       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16305     } catch (std::out_of_range& e) {
16306       {
16307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16308       };
16309     } catch (std::exception& e) {
16310       {
16311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16312       };
16313     } catch (...) {
16314       {
16315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16316       };
16317     }
16318   }
16319   jresult = (void *)result;
16320   return jresult;
16321 }
16322
16323
16324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16325   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16326
16327   arg1 = (Dali::BaseHandle *)jarg1;
16328   {
16329     try {
16330       (arg1)->Reset();
16331     } catch (std::out_of_range& e) {
16332       {
16333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16334       };
16335     } catch (std::exception& e) {
16336       {
16337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16338       };
16339     } catch (...) {
16340       {
16341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16342       };
16343     }
16344   }
16345 }
16346
16347
16348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16349   unsigned int jresult ;
16350   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16351   Dali::BaseHandle *arg2 = 0 ;
16352   bool result;
16353
16354   arg1 = (Dali::BaseHandle *)jarg1;
16355   arg2 = (Dali::BaseHandle *)jarg2;
16356   if (!arg2) {
16357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16358     return 0;
16359   }
16360   {
16361     try {
16362       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16363     } catch (std::out_of_range& e) {
16364       {
16365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16366       };
16367     } catch (std::exception& e) {
16368       {
16369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16370       };
16371     } catch (...) {
16372       {
16373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16374       };
16375     }
16376   }
16377   jresult = result;
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16383   unsigned int jresult ;
16384   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16385   Dali::BaseHandle *arg2 = 0 ;
16386   bool result;
16387
16388   arg1 = (Dali::BaseHandle *)jarg1;
16389   arg2 = (Dali::BaseHandle *)jarg2;
16390   if (!arg2) {
16391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16392     return 0;
16393   }
16394   {
16395     try {
16396       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16397     } catch (std::out_of_range& e) {
16398       {
16399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16400       };
16401     } catch (std::exception& e) {
16402       {
16403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16404       };
16405     } catch (...) {
16406       {
16407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16408       };
16409     }
16410   }
16411   jresult = result;
16412   return jresult;
16413 }
16414
16415
16416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16417   void * jresult ;
16418   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16419   Dali::RefObject *result = 0 ;
16420
16421   arg1 = (Dali::BaseHandle *)jarg1;
16422   {
16423     try {
16424       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16425     } catch (std::out_of_range& e) {
16426       {
16427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16428       };
16429     } catch (std::exception& e) {
16430       {
16431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16432       };
16433     } catch (...) {
16434       {
16435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16436       };
16437     }
16438   }
16439   jresult = (void *)result;
16440   return jresult;
16441 }
16442
16443
16444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16445   unsigned int jresult ;
16446   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16447   bool result;
16448
16449   arg1 = (Dali::BaseHandle *)jarg1;
16450   {
16451     try {
16452       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16453     } catch (std::out_of_range& e) {
16454       {
16455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16456       };
16457     } catch (std::exception& e) {
16458       {
16459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16460       };
16461     } catch (...) {
16462       {
16463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16464       };
16465     }
16466   }
16467   jresult = result;
16468   return jresult;
16469 }
16470
16471
16472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16473   unsigned int jresult ;
16474   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16475   Dali::BaseHandle *arg2 = 0 ;
16476   bool result;
16477
16478   arg1 = (Dali::BaseHandle *)jarg1;
16479   arg2 = (Dali::BaseHandle *)jarg2;
16480   if (!arg2) {
16481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16482     return 0;
16483   }
16484   {
16485     try {
16486       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16487     } catch (std::out_of_range& e) {
16488       {
16489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16490       };
16491     } catch (std::exception& e) {
16492       {
16493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16494       };
16495     } catch (...) {
16496       {
16497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16498       };
16499     }
16500   }
16501   jresult = result;
16502   return jresult;
16503 }
16504
16505
16506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16507   unsigned int jresult ;
16508   Dali::BaseHandle *arg1 = 0 ;
16509   Dali::BaseHandle *arg2 = 0 ;
16510   bool result;
16511
16512   arg1 = (Dali::BaseHandle *)jarg1;
16513   if (!arg1) {
16514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16515     return 0;
16516   }
16517   arg2 = (Dali::BaseHandle *)jarg2;
16518   if (!arg2) {
16519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16520     return 0;
16521   }
16522   {
16523     try {
16524       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16525     } catch (std::out_of_range& e) {
16526       {
16527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16528       };
16529     } catch (std::exception& e) {
16530       {
16531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16532       };
16533     } catch (...) {
16534       {
16535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16536       };
16537     }
16538   }
16539   jresult = result;
16540   return jresult;
16541 }
16542
16543
16544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16545   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16546
16547   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16548   {
16549     try {
16550       delete arg1;
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16558       };
16559     } catch (...) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16562       };
16563     }
16564   }
16565 }
16566
16567
16568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16569   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16570   SlotObserver *arg2 = (SlotObserver *) 0 ;
16571   CallbackBase *arg3 = (CallbackBase *) 0 ;
16572
16573   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16574   arg2 = (SlotObserver *)jarg2;
16575   arg3 = (CallbackBase *)jarg3;
16576   {
16577     try {
16578       (arg1)->SignalConnected(arg2,arg3);
16579     } catch (std::out_of_range& e) {
16580       {
16581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16582       };
16583     } catch (std::exception& e) {
16584       {
16585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16586       };
16587     } catch (...) {
16588       {
16589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16590       };
16591     }
16592   }
16593 }
16594
16595
16596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16597   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16598
16599   arg1 = (Dali::SignalObserver *)jarg1;
16600   {
16601     try {
16602       delete arg1;
16603     } catch (std::out_of_range& e) {
16604       {
16605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16606       };
16607     } catch (std::exception& e) {
16608       {
16609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16610       };
16611     } catch (...) {
16612       {
16613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16614       };
16615     }
16616   }
16617 }
16618
16619
16620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16621   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16622   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16623   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16624
16625   arg1 = (Dali::SignalObserver *)jarg1;
16626   arg2 = (Dali::SlotObserver *)jarg2;
16627   arg3 = (Dali::CallbackBase *)jarg3;
16628   {
16629     try {
16630       (arg1)->SignalDisconnected(arg2,arg3);
16631     } catch (std::out_of_range& e) {
16632       {
16633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16634       };
16635     } catch (std::exception& e) {
16636       {
16637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16638       };
16639     } catch (...) {
16640       {
16641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16642       };
16643     }
16644   }
16645 }
16646
16647
16648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16649   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16650
16651   arg1 = (Dali::SlotObserver *)jarg1;
16652   {
16653     try {
16654       delete arg1;
16655     } catch (std::out_of_range& e) {
16656       {
16657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16658       };
16659     } catch (std::exception& e) {
16660       {
16661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16662       };
16663     } catch (...) {
16664       {
16665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16666       };
16667     }
16668   }
16669 }
16670
16671
16672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16673   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16674   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16675
16676   arg1 = (Dali::SlotObserver *)jarg1;
16677   arg2 = (Dali::CallbackBase *)jarg2;
16678   {
16679     try {
16680       (arg1)->SlotDisconnected(arg2);
16681     } catch (std::out_of_range& e) {
16682       {
16683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16684       };
16685     } catch (std::exception& e) {
16686       {
16687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16688       };
16689     } catch (...) {
16690       {
16691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16692       };
16693     }
16694   }
16695 }
16696
16697
16698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16699   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16700
16701   arg1 = (Dali::ConnectionTracker *)jarg1;
16702   {
16703     try {
16704       delete arg1;
16705     } catch (std::out_of_range& e) {
16706       {
16707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16708       };
16709     } catch (std::exception& e) {
16710       {
16711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16712       };
16713     } catch (...) {
16714       {
16715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16716       };
16717     }
16718   }
16719 }
16720
16721
16722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16723   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16724
16725   arg1 = (Dali::ConnectionTracker *)jarg1;
16726   {
16727     try {
16728       (arg1)->DisconnectAll();
16729     } catch (std::out_of_range& e) {
16730       {
16731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16732       };
16733     } catch (std::exception& e) {
16734       {
16735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16736       };
16737     } catch (...) {
16738       {
16739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16740       };
16741     }
16742   }
16743 }
16744
16745
16746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16747   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16748   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16749   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16750
16751   arg1 = (Dali::ConnectionTracker *)jarg1;
16752   arg2 = (Dali::SlotObserver *)jarg2;
16753   arg3 = (Dali::CallbackBase *)jarg3;
16754   {
16755     try {
16756       (arg1)->SignalConnected(arg2,arg3);
16757     } catch (std::out_of_range& e) {
16758       {
16759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16760       };
16761     } catch (std::exception& e) {
16762       {
16763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16764       };
16765     } catch (...) {
16766       {
16767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16768       };
16769     }
16770   }
16771 }
16772
16773
16774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16775   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16776   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16777   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16778
16779   arg1 = (Dali::ConnectionTracker *)jarg1;
16780   arg2 = (Dali::SlotObserver *)jarg2;
16781   arg3 = (Dali::CallbackBase *)jarg3;
16782   {
16783     try {
16784       (arg1)->SignalDisconnected(arg2,arg3);
16785     } catch (std::out_of_range& e) {
16786       {
16787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16788       };
16789     } catch (std::exception& e) {
16790       {
16791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16792       };
16793     } catch (...) {
16794       {
16795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16796       };
16797     }
16798   }
16799 }
16800
16801
16802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16803   unsigned long jresult ;
16804   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16805   std::size_t result;
16806
16807   arg1 = (Dali::ConnectionTracker *)jarg1;
16808   {
16809     try {
16810       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16811     } catch (std::out_of_range& e) {
16812       {
16813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16814       };
16815     } catch (std::exception& e) {
16816       {
16817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16818       };
16819     } catch (...) {
16820       {
16821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16822       };
16823     }
16824   }
16825   jresult = (unsigned long)result;
16826   return jresult;
16827 }
16828
16829
16830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16831   void * jresult ;
16832   Dali::ObjectRegistry *result = 0 ;
16833
16834   {
16835     try {
16836       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16837     } catch (std::out_of_range& e) {
16838       {
16839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16840       };
16841     } catch (std::exception& e) {
16842       {
16843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16844       };
16845     } catch (...) {
16846       {
16847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16848       };
16849     }
16850   }
16851   jresult = (void *)result;
16852   return jresult;
16853 }
16854
16855
16856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16857   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16858
16859   arg1 = (Dali::ObjectRegistry *)jarg1;
16860   {
16861     try {
16862       delete arg1;
16863     } catch (std::out_of_range& e) {
16864       {
16865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16866       };
16867     } catch (std::exception& e) {
16868       {
16869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16870       };
16871     } catch (...) {
16872       {
16873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16874       };
16875     }
16876   }
16877 }
16878
16879
16880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16881   void * jresult ;
16882   Dali::ObjectRegistry *arg1 = 0 ;
16883   Dali::ObjectRegistry *result = 0 ;
16884
16885   arg1 = (Dali::ObjectRegistry *)jarg1;
16886   if (!arg1) {
16887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16888     return 0;
16889   }
16890   {
16891     try {
16892       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16893     } catch (std::out_of_range& e) {
16894       {
16895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16896       };
16897     } catch (std::exception& e) {
16898       {
16899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (...) {
16902       {
16903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16904       };
16905     }
16906   }
16907   jresult = (void *)result;
16908   return jresult;
16909 }
16910
16911
16912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16913   void * jresult ;
16914   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16915   Dali::ObjectRegistry *arg2 = 0 ;
16916   Dali::ObjectRegistry *result = 0 ;
16917
16918   arg1 = (Dali::ObjectRegistry *)jarg1;
16919   arg2 = (Dali::ObjectRegistry *)jarg2;
16920   if (!arg2) {
16921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16922     return 0;
16923   }
16924   {
16925     try {
16926       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16927     } catch (std::out_of_range& e) {
16928       {
16929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16930       };
16931     } catch (std::exception& e) {
16932       {
16933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16934       };
16935     } catch (...) {
16936       {
16937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16938       };
16939     }
16940   }
16941   jresult = (void *)result;
16942   return jresult;
16943 }
16944
16945
16946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16947   void * jresult ;
16948   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16949   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16950
16951   arg1 = (Dali::ObjectRegistry *)jarg1;
16952   {
16953     try {
16954       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16955     } catch (std::out_of_range& e) {
16956       {
16957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16958       };
16959     } catch (std::exception& e) {
16960       {
16961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16962       };
16963     } catch (...) {
16964       {
16965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16966       };
16967     }
16968   }
16969   jresult = (void *)result;
16970   return jresult;
16971 }
16972
16973
16974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16975   void * jresult ;
16976   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16977   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16978
16979   arg1 = (Dali::ObjectRegistry *)jarg1;
16980   {
16981     try {
16982       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16983     } catch (std::out_of_range& e) {
16984       {
16985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16986       };
16987     } catch (std::exception& e) {
16988       {
16989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16990       };
16991     } catch (...) {
16992       {
16993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16994       };
16995     }
16996   }
16997   jresult = (void *)result;
16998   return jresult;
16999 }
17000
17001
17002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17003   void * jresult ;
17004   Dali::PropertyCondition *result = 0 ;
17005
17006   {
17007     try {
17008       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (...) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17020       };
17021     }
17022   }
17023   jresult = (void *)result;
17024   return jresult;
17025 }
17026
17027
17028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17029   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17030
17031   arg1 = (Dali::PropertyCondition *)jarg1;
17032   {
17033     try {
17034       delete arg1;
17035     } catch (std::out_of_range& e) {
17036       {
17037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17038       };
17039     } catch (std::exception& e) {
17040       {
17041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17042       };
17043     } catch (...) {
17044       {
17045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17046       };
17047     }
17048   }
17049 }
17050
17051
17052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17053   void * jresult ;
17054   Dali::PropertyCondition *arg1 = 0 ;
17055   Dali::PropertyCondition *result = 0 ;
17056
17057   arg1 = (Dali::PropertyCondition *)jarg1;
17058   if (!arg1) {
17059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17060     return 0;
17061   }
17062   {
17063     try {
17064       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17065     } catch (std::out_of_range& e) {
17066       {
17067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17068       };
17069     } catch (std::exception& e) {
17070       {
17071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17072       };
17073     } catch (...) {
17074       {
17075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17076       };
17077     }
17078   }
17079   jresult = (void *)result;
17080   return jresult;
17081 }
17082
17083
17084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17085   void * jresult ;
17086   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17087   Dali::PropertyCondition *arg2 = 0 ;
17088   Dali::PropertyCondition *result = 0 ;
17089
17090   arg1 = (Dali::PropertyCondition *)jarg1;
17091   arg2 = (Dali::PropertyCondition *)jarg2;
17092   if (!arg2) {
17093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17094     return 0;
17095   }
17096   {
17097     try {
17098       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17099     } catch (std::out_of_range& e) {
17100       {
17101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17102       };
17103     } catch (std::exception& e) {
17104       {
17105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17106       };
17107     } catch (...) {
17108       {
17109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17110       };
17111     }
17112   }
17113   jresult = (void *)result;
17114   return jresult;
17115 }
17116
17117
17118 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17119   unsigned long jresult ;
17120   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17121   std::size_t result;
17122
17123   arg1 = (Dali::PropertyCondition *)jarg1;
17124   {
17125     try {
17126       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17127     } catch (std::out_of_range& e) {
17128       {
17129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (std::exception& e) {
17132       {
17133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17134       };
17135     } catch (...) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17138       };
17139     }
17140   }
17141   jresult = (unsigned long)result;
17142   return jresult;
17143 }
17144
17145
17146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17147   float jresult ;
17148   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17149   std::size_t arg2 ;
17150   float result;
17151
17152   arg1 = (Dali::PropertyCondition *)jarg1;
17153   arg2 = (std::size_t)jarg2;
17154   {
17155     try {
17156       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17157     } catch (std::out_of_range& e) {
17158       {
17159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17160       };
17161     } catch (std::exception& e) {
17162       {
17163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (...) {
17166       {
17167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17168       };
17169     }
17170   }
17171   jresult = result;
17172   return jresult;
17173 }
17174
17175
17176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17177   void * jresult ;
17178   float arg1 ;
17179   Dali::PropertyCondition result;
17180
17181   arg1 = (float)jarg1;
17182   {
17183     try {
17184       result = Dali::LessThanCondition(arg1);
17185     } catch (std::out_of_range& e) {
17186       {
17187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17188       };
17189     } catch (std::exception& e) {
17190       {
17191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17192       };
17193     } catch (...) {
17194       {
17195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17196       };
17197     }
17198   }
17199   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17200   return jresult;
17201 }
17202
17203
17204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17205   void * jresult ;
17206   float arg1 ;
17207   Dali::PropertyCondition result;
17208
17209   arg1 = (float)jarg1;
17210   {
17211     try {
17212       result = Dali::GreaterThanCondition(arg1);
17213     } catch (std::out_of_range& e) {
17214       {
17215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17216       };
17217     } catch (std::exception& e) {
17218       {
17219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17220       };
17221     } catch (...) {
17222       {
17223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17224       };
17225     }
17226   }
17227   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17228   return jresult;
17229 }
17230
17231
17232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17233   void * jresult ;
17234   float arg1 ;
17235   float arg2 ;
17236   Dali::PropertyCondition result;
17237
17238   arg1 = (float)jarg1;
17239   arg2 = (float)jarg2;
17240   {
17241     try {
17242       result = Dali::InsideCondition(arg1,arg2);
17243     } catch (std::out_of_range& e) {
17244       {
17245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17246       };
17247     } catch (std::exception& e) {
17248       {
17249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17250       };
17251     } catch (...) {
17252       {
17253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17254       };
17255     }
17256   }
17257   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17258   return jresult;
17259 }
17260
17261
17262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17263   void * jresult ;
17264   float arg1 ;
17265   float arg2 ;
17266   Dali::PropertyCondition result;
17267
17268   arg1 = (float)jarg1;
17269   arg2 = (float)jarg2;
17270   {
17271     try {
17272       result = Dali::OutsideCondition(arg1,arg2);
17273     } catch (std::out_of_range& e) {
17274       {
17275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (std::exception& e) {
17278       {
17279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17280       };
17281     } catch (...) {
17282       {
17283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17284       };
17285     }
17286   }
17287   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17288   return jresult;
17289 }
17290
17291
17292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17293   void * jresult ;
17294   float arg1 ;
17295   float arg2 ;
17296   Dali::PropertyCondition result;
17297
17298   arg1 = (float)jarg1;
17299   arg2 = (float)jarg2;
17300   {
17301     try {
17302       result = Dali::StepCondition(arg1,arg2);
17303     } catch (std::out_of_range& e) {
17304       {
17305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (std::exception& e) {
17308       {
17309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (...) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17314       };
17315     }
17316   }
17317   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17318   return jresult;
17319 }
17320
17321
17322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17323   void * jresult ;
17324   float arg1 ;
17325   Dali::PropertyCondition result;
17326
17327   arg1 = (float)jarg1;
17328   {
17329     try {
17330       result = Dali::StepCondition(arg1);
17331     } catch (std::out_of_range& e) {
17332       {
17333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17334       };
17335     } catch (std::exception& e) {
17336       {
17337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17338       };
17339     } catch (...) {
17340       {
17341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17342       };
17343     }
17344   }
17345   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17346   return jresult;
17347 }
17348
17349
17350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17351   void * jresult ;
17352   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17353   Dali::PropertyCondition result;
17354
17355   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17356   if (!arg1) {
17357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17358     return 0;
17359   }
17360   {
17361     try {
17362       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17363     } catch (std::out_of_range& e) {
17364       {
17365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (std::exception& e) {
17368       {
17369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (...) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17374       };
17375     }
17376   }
17377   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17378   return jresult;
17379 }
17380
17381
17382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17383   void * jresult ;
17384   Dali::PropertyNotification *result = 0 ;
17385
17386   {
17387     try {
17388       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17389     } catch (std::out_of_range& e) {
17390       {
17391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17392       };
17393     } catch (std::exception& e) {
17394       {
17395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17396       };
17397     } catch (...) {
17398       {
17399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17400       };
17401     }
17402   }
17403   jresult = (void *)result;
17404   return jresult;
17405 }
17406
17407
17408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17409   void * jresult ;
17410   Dali::BaseHandle arg1 ;
17411   Dali::BaseHandle *argp1 ;
17412   Dali::PropertyNotification result;
17413
17414   argp1 = (Dali::BaseHandle *)jarg1;
17415   if (!argp1) {
17416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17417     return 0;
17418   }
17419   arg1 = *argp1;
17420   {
17421     try {
17422       result = Dali::PropertyNotification::DownCast(arg1);
17423     } catch (std::out_of_range& e) {
17424       {
17425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17426       };
17427     } catch (std::exception& e) {
17428       {
17429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17430       };
17431     } catch (...) {
17432       {
17433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17434       };
17435     }
17436   }
17437   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17438   return jresult;
17439 }
17440
17441
17442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17443   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17444
17445   arg1 = (Dali::PropertyNotification *)jarg1;
17446   {
17447     try {
17448       delete arg1;
17449     } catch (std::out_of_range& e) {
17450       {
17451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17452       };
17453     } catch (std::exception& e) {
17454       {
17455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17456       };
17457     } catch (...) {
17458       {
17459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17460       };
17461     }
17462   }
17463 }
17464
17465
17466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17467   void * jresult ;
17468   Dali::PropertyNotification *arg1 = 0 ;
17469   Dali::PropertyNotification *result = 0 ;
17470
17471   arg1 = (Dali::PropertyNotification *)jarg1;
17472   if (!arg1) {
17473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17474     return 0;
17475   }
17476   {
17477     try {
17478       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17479     } catch (std::out_of_range& e) {
17480       {
17481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17482       };
17483     } catch (std::exception& e) {
17484       {
17485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17486       };
17487     } catch (...) {
17488       {
17489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17490       };
17491     }
17492   }
17493   jresult = (void *)result;
17494   return jresult;
17495 }
17496
17497
17498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17499   void * jresult ;
17500   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17501   Dali::PropertyNotification *arg2 = 0 ;
17502   Dali::PropertyNotification *result = 0 ;
17503
17504   arg1 = (Dali::PropertyNotification *)jarg1;
17505   arg2 = (Dali::PropertyNotification *)jarg2;
17506   if (!arg2) {
17507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17508     return 0;
17509   }
17510   {
17511     try {
17512       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17513     } catch (std::out_of_range& e) {
17514       {
17515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (std::exception& e) {
17518       {
17519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527   jresult = (void *)result;
17528   return jresult;
17529 }
17530
17531
17532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17533   void * jresult ;
17534   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17535   Dali::PropertyCondition result;
17536
17537   arg1 = (Dali::PropertyNotification *)jarg1;
17538   {
17539     try {
17540       result = (arg1)->GetCondition();
17541     } catch (std::out_of_range& e) {
17542       {
17543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17544       };
17545     } catch (std::exception& e) {
17546       {
17547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17548       };
17549     } catch (...) {
17550       {
17551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17552       };
17553     }
17554   }
17555   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17556   return jresult;
17557 }
17558
17559
17560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17561   void * jresult ;
17562   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17563   Dali::Handle result;
17564
17565   arg1 = (Dali::PropertyNotification *)jarg1;
17566   {
17567     try {
17568       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17569     } catch (std::out_of_range& e) {
17570       {
17571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17572       };
17573     } catch (std::exception& e) {
17574       {
17575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17576       };
17577     } catch (...) {
17578       {
17579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17580       };
17581     }
17582   }
17583   jresult = new Dali::Handle((const Dali::Handle &)result);
17584   return jresult;
17585 }
17586
17587
17588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17589   int jresult ;
17590   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17591   Dali::Property::Index result;
17592
17593   arg1 = (Dali::PropertyNotification *)jarg1;
17594   {
17595     try {
17596       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17597     } catch (std::out_of_range& e) {
17598       {
17599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17600       };
17601     } catch (std::exception& e) {
17602       {
17603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (...) {
17606       {
17607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17608       };
17609     }
17610   }
17611   jresult = result;
17612   return jresult;
17613 }
17614
17615
17616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17617   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17618   Dali::PropertyNotification::NotifyMode arg2 ;
17619
17620   arg1 = (Dali::PropertyNotification *)jarg1;
17621   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17622   {
17623     try {
17624       (arg1)->SetNotifyMode(arg2);
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17632       };
17633     } catch (...) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17636       };
17637     }
17638   }
17639 }
17640
17641
17642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17643   int jresult ;
17644   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17645   Dali::PropertyNotification::NotifyMode result;
17646
17647   arg1 = (Dali::PropertyNotification *)jarg1;
17648   {
17649     try {
17650       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17651     } catch (std::out_of_range& e) {
17652       {
17653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17654       };
17655     } catch (std::exception& e) {
17656       {
17657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17658       };
17659     } catch (...) {
17660       {
17661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17662       };
17663     }
17664   }
17665   jresult = (int)result;
17666   return jresult;
17667 }
17668
17669
17670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17671   unsigned int jresult ;
17672   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17673   bool result;
17674
17675   arg1 = (Dali::PropertyNotification *)jarg1;
17676   {
17677     try {
17678       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17679     } catch (std::out_of_range& e) {
17680       {
17681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17682       };
17683     } catch (std::exception& e) {
17684       {
17685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17686       };
17687     } catch (...) {
17688       {
17689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17690       };
17691     }
17692   }
17693   jresult = result;
17694   return jresult;
17695 }
17696
17697
17698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17699   void * jresult ;
17700   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17701   Dali::PropertyNotifySignalType *result = 0 ;
17702
17703   arg1 = (Dali::PropertyNotification *)jarg1;
17704   {
17705     try {
17706       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17707     } catch (std::out_of_range& e) {
17708       {
17709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17710       };
17711     } catch (std::exception& e) {
17712       {
17713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17714       };
17715     } catch (...) {
17716       {
17717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17718       };
17719     }
17720   }
17721   jresult = (void *)result;
17722   return jresult;
17723 }
17724
17725
17726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17727   void * jresult ;
17728   Dali::Handle *result = 0 ;
17729
17730   {
17731     try {
17732       result = (Dali::Handle *)new Dali::Handle();
17733     } catch (std::out_of_range& e) {
17734       {
17735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17736       };
17737     } catch (std::exception& e) {
17738       {
17739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17740       };
17741     } catch (...) {
17742       {
17743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17744       };
17745     }
17746   }
17747   jresult = (void *)result;
17748   return jresult;
17749 }
17750
17751
17752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17753   void * jresult ;
17754   Dali::Handle result;
17755
17756   {
17757     try {
17758       result = Dali::Handle::New();
17759     } catch (std::out_of_range& e) {
17760       {
17761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17762       };
17763     } catch (std::exception& e) {
17764       {
17765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (...) {
17768       {
17769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17770       };
17771     }
17772   }
17773   jresult = new Dali::Handle((const Dali::Handle &)result);
17774   return jresult;
17775 }
17776
17777
17778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17779   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17780
17781   arg1 = (Dali::Handle *)jarg1;
17782   {
17783     try {
17784       delete arg1;
17785     } catch (std::out_of_range& e) {
17786       {
17787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17788       };
17789     } catch (std::exception& e) {
17790       {
17791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17792       };
17793     } catch (...) {
17794       {
17795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17796       };
17797     }
17798   }
17799 }
17800
17801
17802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17803   void * jresult ;
17804   Dali::Handle *arg1 = 0 ;
17805   Dali::Handle *result = 0 ;
17806
17807   arg1 = (Dali::Handle *)jarg1;
17808   if (!arg1) {
17809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17810     return 0;
17811   }
17812   {
17813     try {
17814       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17815     } catch (std::out_of_range& e) {
17816       {
17817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17818       };
17819     } catch (std::exception& e) {
17820       {
17821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (...) {
17824       {
17825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17826       };
17827     }
17828   }
17829   jresult = (void *)result;
17830   return jresult;
17831 }
17832
17833
17834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17835   void * jresult ;
17836   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17837   Dali::Handle *arg2 = 0 ;
17838   Dali::Handle *result = 0 ;
17839
17840   arg1 = (Dali::Handle *)jarg1;
17841   arg2 = (Dali::Handle *)jarg2;
17842   if (!arg2) {
17843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17844     return 0;
17845   }
17846   {
17847     try {
17848       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17849     } catch (std::out_of_range& e) {
17850       {
17851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17852       };
17853     } catch (std::exception& e) {
17854       {
17855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17856       };
17857     } catch (...) {
17858       {
17859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17860       };
17861     }
17862   }
17863   jresult = (void *)result;
17864   return jresult;
17865 }
17866
17867
17868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17869   void * jresult ;
17870   Dali::BaseHandle arg1 ;
17871   Dali::BaseHandle *argp1 ;
17872   Dali::Handle result;
17873
17874   argp1 = (Dali::BaseHandle *)jarg1;
17875   if (!argp1) {
17876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17877     return 0;
17878   }
17879   arg1 = *argp1;
17880   {
17881     try {
17882       result = Dali::Handle::DownCast(arg1);
17883     } catch (std::out_of_range& e) {
17884       {
17885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17886       };
17887     } catch (std::exception& e) {
17888       {
17889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17890       };
17891     } catch (...) {
17892       {
17893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17894       };
17895     }
17896   }
17897   jresult = new Dali::Handle((const Dali::Handle &)result);
17898   return jresult;
17899 }
17900
17901
17902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17903   unsigned int jresult ;
17904   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17905   Dali::Handle::Capability arg2 ;
17906   bool result;
17907
17908   arg1 = (Dali::Handle *)jarg1;
17909   arg2 = (Dali::Handle::Capability)jarg2;
17910   {
17911     try {
17912       result = (bool)((Dali::Handle const *)arg1)->Supports(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 = result;
17928   return jresult;
17929 }
17930
17931
17932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17933   unsigned int jresult ;
17934   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17935   unsigned int result;
17936
17937   arg1 = (Dali::Handle *)jarg1;
17938   {
17939     try {
17940       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17941     } catch (std::out_of_range& e) {
17942       {
17943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17944       };
17945     } catch (std::exception& e) {
17946       {
17947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (...) {
17950       {
17951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17952       };
17953     }
17954   }
17955   jresult = result;
17956   return jresult;
17957 }
17958
17959
17960 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17961   char * jresult ;
17962   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17963   Dali::Property::Index arg2 ;
17964   std::string result;
17965
17966   arg1 = (Dali::Handle *)jarg1;
17967   arg2 = (Dali::Property::Index)jarg2;
17968   {
17969     try {
17970       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17971     } catch (std::out_of_range& e) {
17972       {
17973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (std::exception& e) {
17976       {
17977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (...) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17982       };
17983     }
17984   }
17985   jresult = SWIG_csharp_string_callback((&result)->c_str());
17986   return jresult;
17987 }
17988
17989
17990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17991   int jresult ;
17992   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17993   std::string *arg2 = 0 ;
17994   Dali::Property::Index result;
17995
17996   arg1 = (Dali::Handle *)jarg1;
17997   if (!jarg2) {
17998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17999     return 0;
18000   }
18001   std::string arg2_str(jarg2);
18002   arg2 = &arg2_str;
18003   {
18004     try {
18005       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18006     } catch (std::out_of_range& e) {
18007       {
18008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (std::exception& e) {
18011       {
18012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18013       };
18014     } catch (...) {
18015       {
18016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18017       };
18018     }
18019   }
18020   jresult = result;
18021
18022   //argout typemap for const std::string&
18023
18024   return jresult;
18025 }
18026
18027
18028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18029   unsigned int jresult ;
18030   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18031   Dali::Property::Index arg2 ;
18032   bool result;
18033
18034   arg1 = (Dali::Handle *)jarg1;
18035   arg2 = (Dali::Property::Index)jarg2;
18036   {
18037     try {
18038       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18039     } catch (std::out_of_range& e) {
18040       {
18041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (std::exception& e) {
18044       {
18045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18046       };
18047     } catch (...) {
18048       {
18049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18050       };
18051     }
18052   }
18053   jresult = result;
18054   return jresult;
18055 }
18056
18057
18058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18059   unsigned int jresult ;
18060   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18061   Dali::Property::Index arg2 ;
18062   bool result;
18063
18064   arg1 = (Dali::Handle *)jarg1;
18065   arg2 = (Dali::Property::Index)jarg2;
18066   {
18067     try {
18068       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18069     } catch (std::out_of_range& e) {
18070       {
18071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18072       };
18073     } catch (std::exception& e) {
18074       {
18075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18076       };
18077     } catch (...) {
18078       {
18079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18080       };
18081     }
18082   }
18083   jresult = result;
18084   return jresult;
18085 }
18086
18087
18088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18089   unsigned int jresult ;
18090   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18091   Dali::Property::Index arg2 ;
18092   bool result;
18093
18094   arg1 = (Dali::Handle *)jarg1;
18095   arg2 = (Dali::Property::Index)jarg2;
18096   {
18097     try {
18098       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18099     } catch (std::out_of_range& e) {
18100       {
18101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18102       };
18103     } catch (std::exception& e) {
18104       {
18105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18106       };
18107     } catch (...) {
18108       {
18109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18110       };
18111     }
18112   }
18113   jresult = result;
18114   return jresult;
18115 }
18116
18117
18118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18119   int jresult ;
18120   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18121   Dali::Property::Index arg2 ;
18122   Dali::Property::Type result;
18123
18124   arg1 = (Dali::Handle *)jarg1;
18125   arg2 = (Dali::Property::Index)jarg2;
18126   {
18127     try {
18128       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18129     } catch (std::out_of_range& e) {
18130       {
18131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18132       };
18133     } catch (std::exception& e) {
18134       {
18135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18136       };
18137     } catch (...) {
18138       {
18139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18140       };
18141     }
18142   }
18143   jresult = (int)result;
18144   return jresult;
18145 }
18146
18147
18148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18149   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18150   Dali::Property::Index arg2 ;
18151   Dali::Property::Value *arg3 = 0 ;
18152
18153   arg1 = (Dali::Handle *)jarg1;
18154   arg2 = (Dali::Property::Index)jarg2;
18155   arg3 = (Dali::Property::Value *)jarg3;
18156   if (!arg3) {
18157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18158     return ;
18159   }
18160   {
18161     try {
18162       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18163     } catch (std::out_of_range& e) {
18164       {
18165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18166       };
18167     } catch (std::exception& e) {
18168       {
18169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18170       };
18171     } catch (...) {
18172       {
18173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18174       };
18175     }
18176   }
18177 }
18178
18179
18180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18181   int jresult ;
18182   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18183   std::string *arg2 = 0 ;
18184   Dali::Property::Value *arg3 = 0 ;
18185   Dali::Property::Index result;
18186
18187   arg1 = (Dali::Handle *)jarg1;
18188   if (!jarg2) {
18189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18190     return 0;
18191   }
18192   std::string arg2_str(jarg2);
18193   arg2 = &arg2_str;
18194   arg3 = (Dali::Property::Value *)jarg3;
18195   if (!arg3) {
18196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18197     return 0;
18198   }
18199   {
18200     try {
18201       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18202     } catch (std::out_of_range& e) {
18203       {
18204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (std::exception& e) {
18207       {
18208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18209       };
18210     } catch (...) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18213       };
18214     }
18215   }
18216   jresult = result;
18217
18218   //argout typemap for const std::string&
18219
18220   return jresult;
18221 }
18222
18223
18224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18225   int jresult ;
18226   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18227   std::string *arg2 = 0 ;
18228   Dali::Property::Value *arg3 = 0 ;
18229   Dali::Property::AccessMode arg4 ;
18230   Dali::Property::Index result;
18231
18232   arg1 = (Dali::Handle *)jarg1;
18233   if (!jarg2) {
18234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18235     return 0;
18236   }
18237   std::string arg2_str(jarg2);
18238   arg2 = &arg2_str;
18239   arg3 = (Dali::Property::Value *)jarg3;
18240   if (!arg3) {
18241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18242     return 0;
18243   }
18244   arg4 = (Dali::Property::AccessMode)jarg4;
18245   {
18246     try {
18247       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18248     } catch (std::out_of_range& e) {
18249       {
18250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18251       };
18252     } catch (std::exception& e) {
18253       {
18254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18255       };
18256     } catch (...) {
18257       {
18258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18259       };
18260     }
18261   }
18262   jresult = result;
18263
18264   //argout typemap for const std::string&
18265
18266   return jresult;
18267 }
18268
18269
18270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18271   void * jresult ;
18272   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18273   Dali::Property::Index arg2 ;
18274   Dali::Property::Value result;
18275
18276   arg1 = (Dali::Handle *)jarg1;
18277   arg2 = (Dali::Property::Index)jarg2;
18278   {
18279     try {
18280       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18281     } catch (std::out_of_range& e) {
18282       {
18283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18284       };
18285     } catch (std::exception& e) {
18286       {
18287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18288       };
18289     } catch (...) {
18290       {
18291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18292       };
18293     }
18294   }
18295   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18296   return jresult;
18297 }
18298
18299
18300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18301   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18302   Dali::Property::IndexContainer *arg2 = 0 ;
18303
18304   arg1 = (Dali::Handle *)jarg1;
18305   arg2 = (Dali::Property::IndexContainer *)jarg2;
18306   if (!arg2) {
18307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18308     return ;
18309   }
18310   {
18311     try {
18312       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18313     } catch (std::out_of_range& e) {
18314       {
18315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18316       };
18317     } catch (std::exception& e) {
18318       {
18319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18320       };
18321     } catch (...) {
18322       {
18323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18324       };
18325     }
18326   }
18327 }
18328
18329
18330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18331   void * jresult ;
18332   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18333   Dali::Property::Index arg2 ;
18334   Dali::PropertyCondition *arg3 = 0 ;
18335   Dali::PropertyNotification result;
18336
18337   arg1 = (Dali::Handle *)jarg1;
18338   arg2 = (Dali::Property::Index)jarg2;
18339   arg3 = (Dali::PropertyCondition *)jarg3;
18340   if (!arg3) {
18341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18342     return 0;
18343   }
18344   {
18345     try {
18346       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18347     } catch (std::out_of_range& e) {
18348       {
18349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18350       };
18351     } catch (std::exception& e) {
18352       {
18353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18354       };
18355     } catch (...) {
18356       {
18357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18358       };
18359     }
18360   }
18361   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18362   return jresult;
18363 }
18364
18365
18366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18367   void * jresult ;
18368   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18369   Dali::Property::Index arg2 ;
18370   int arg3 ;
18371   Dali::PropertyCondition *arg4 = 0 ;
18372   Dali::PropertyNotification result;
18373
18374   arg1 = (Dali::Handle *)jarg1;
18375   arg2 = (Dali::Property::Index)jarg2;
18376   arg3 = (int)jarg3;
18377   arg4 = (Dali::PropertyCondition *)jarg4;
18378   if (!arg4) {
18379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18380     return 0;
18381   }
18382   {
18383     try {
18384       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18385     } catch (std::out_of_range& e) {
18386       {
18387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18388       };
18389     } catch (std::exception& e) {
18390       {
18391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18392       };
18393     } catch (...) {
18394       {
18395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18396       };
18397     }
18398   }
18399   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18400   return jresult;
18401 }
18402
18403
18404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18405   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18406   Dali::PropertyNotification arg2 ;
18407   Dali::PropertyNotification *argp2 ;
18408
18409   arg1 = (Dali::Handle *)jarg1;
18410   argp2 = (Dali::PropertyNotification *)jarg2;
18411   if (!argp2) {
18412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18413     return ;
18414   }
18415   arg2 = *argp2;
18416   {
18417     try {
18418       (arg1)->RemovePropertyNotification(arg2);
18419     } catch (std::out_of_range& e) {
18420       {
18421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18422       };
18423     } catch (std::exception& e) {
18424       {
18425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18426       };
18427     } catch (...) {
18428       {
18429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18430       };
18431     }
18432   }
18433 }
18434
18435
18436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18437   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18438
18439   arg1 = (Dali::Handle *)jarg1;
18440   {
18441     try {
18442       (arg1)->RemovePropertyNotifications();
18443     } catch (std::out_of_range& e) {
18444       {
18445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18446       };
18447     } catch (std::exception& e) {
18448       {
18449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18450       };
18451     } catch (...) {
18452       {
18453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18454       };
18455     }
18456   }
18457 }
18458
18459
18460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18461   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18462
18463   arg1 = (Dali::Handle *)jarg1;
18464   {
18465     try {
18466       (arg1)->RemoveConstraints();
18467     } catch (std::out_of_range& e) {
18468       {
18469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18470       };
18471     } catch (std::exception& e) {
18472       {
18473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18474       };
18475     } catch (...) {
18476       {
18477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18478       };
18479     }
18480   }
18481 }
18482
18483
18484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18485   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18486   unsigned int arg2 ;
18487
18488   arg1 = (Dali::Handle *)jarg1;
18489   arg2 = (unsigned int)jarg2;
18490   {
18491     try {
18492       (arg1)->RemoveConstraints(arg2);
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18500       };
18501     } catch (...) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18504       };
18505     }
18506   }
18507 }
18508
18509
18510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18511   int jresult ;
18512   Dali::Property::Index result;
18513
18514   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18515   jresult = result;
18516   return jresult;
18517 }
18518
18519
18520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18521   void * jresult ;
18522   Dali::Handle result;
18523
18524   {
18525     try {
18526       result = Dali::WeightObject::New();
18527     } catch (std::out_of_range& e) {
18528       {
18529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18530       };
18531     } catch (std::exception& e) {
18532       {
18533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (...) {
18536       {
18537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18538       };
18539     }
18540   }
18541   jresult = new Dali::Handle((const Dali::Handle &)result);
18542   return jresult;
18543 }
18544
18545
18546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18547   void * jresult ;
18548   Dali::TypeInfo *result = 0 ;
18549
18550   {
18551     try {
18552       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18553     } catch (std::out_of_range& e) {
18554       {
18555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18556       };
18557     } catch (std::exception& e) {
18558       {
18559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18560       };
18561     } catch (...) {
18562       {
18563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18564       };
18565     }
18566   }
18567   jresult = (void *)result;
18568   return jresult;
18569 }
18570
18571
18572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18573   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18574
18575   arg1 = (Dali::TypeInfo *)jarg1;
18576   {
18577     try {
18578       delete arg1;
18579     } catch (std::out_of_range& e) {
18580       {
18581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18582       };
18583     } catch (std::exception& e) {
18584       {
18585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18586       };
18587     } catch (...) {
18588       {
18589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18590       };
18591     }
18592   }
18593 }
18594
18595
18596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18597   void * jresult ;
18598   Dali::TypeInfo *arg1 = 0 ;
18599   Dali::TypeInfo *result = 0 ;
18600
18601   arg1 = (Dali::TypeInfo *)jarg1;
18602   if (!arg1) {
18603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18604     return 0;
18605   }
18606   {
18607     try {
18608       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18609     } catch (std::out_of_range& e) {
18610       {
18611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18612       };
18613     } catch (std::exception& e) {
18614       {
18615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18616       };
18617     } catch (...) {
18618       {
18619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18620       };
18621     }
18622   }
18623   jresult = (void *)result;
18624   return jresult;
18625 }
18626
18627
18628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18629   void * jresult ;
18630   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18631   Dali::TypeInfo *arg2 = 0 ;
18632   Dali::TypeInfo *result = 0 ;
18633
18634   arg1 = (Dali::TypeInfo *)jarg1;
18635   arg2 = (Dali::TypeInfo *)jarg2;
18636   if (!arg2) {
18637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18638     return 0;
18639   }
18640   {
18641     try {
18642       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18643     } catch (std::out_of_range& e) {
18644       {
18645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18646       };
18647     } catch (std::exception& e) {
18648       {
18649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18650       };
18651     } catch (...) {
18652       {
18653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18654       };
18655     }
18656   }
18657   jresult = (void *)result;
18658   return jresult;
18659 }
18660
18661
18662 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18663   char * jresult ;
18664   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18665   std::string *result = 0 ;
18666
18667   arg1 = (Dali::TypeInfo *)jarg1;
18668   {
18669     try {
18670       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18671     } catch (std::out_of_range& e) {
18672       {
18673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18674       };
18675     } catch (std::exception& e) {
18676       {
18677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18678       };
18679     } catch (...) {
18680       {
18681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18682       };
18683     }
18684   }
18685   jresult = SWIG_csharp_string_callback(result->c_str());
18686   return jresult;
18687 }
18688
18689
18690 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18691   char * jresult ;
18692   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18693   std::string *result = 0 ;
18694
18695   arg1 = (Dali::TypeInfo *)jarg1;
18696   {
18697     try {
18698       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18699     } catch (std::out_of_range& e) {
18700       {
18701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18702       };
18703     } catch (std::exception& e) {
18704       {
18705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18706       };
18707     } catch (...) {
18708       {
18709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18710       };
18711     }
18712   }
18713   jresult = SWIG_csharp_string_callback(result->c_str());
18714   return jresult;
18715 }
18716
18717
18718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18719   void * jresult ;
18720   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18721   Dali::BaseHandle result;
18722
18723   arg1 = (Dali::TypeInfo *)jarg1;
18724   {
18725     try {
18726       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18727     } catch (std::out_of_range& e) {
18728       {
18729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (std::exception& e) {
18732       {
18733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (...) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18738       };
18739     }
18740   }
18741   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18742   return jresult;
18743 }
18744
18745
18746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18747   unsigned long jresult ;
18748   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18749   size_t result;
18750
18751   arg1 = (Dali::TypeInfo *)jarg1;
18752   {
18753     try {
18754       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18755     } catch (std::out_of_range& e) {
18756       {
18757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18758       };
18759     } catch (std::exception& e) {
18760       {
18761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18762       };
18763     } catch (...) {
18764       {
18765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18766       };
18767     }
18768   }
18769   jresult = (unsigned long)result;
18770   return jresult;
18771 }
18772
18773
18774 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18775   char * jresult ;
18776   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18777   size_t arg2 ;
18778   std::string result;
18779
18780   arg1 = (Dali::TypeInfo *)jarg1;
18781   arg2 = (size_t)jarg2;
18782   {
18783     try {
18784       result = (arg1)->GetActionName(arg2);
18785     } catch (std::out_of_range& e) {
18786       {
18787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18788       };
18789     } catch (std::exception& e) {
18790       {
18791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18792       };
18793     } catch (...) {
18794       {
18795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18796       };
18797     }
18798   }
18799   jresult = SWIG_csharp_string_callback((&result)->c_str());
18800   return jresult;
18801 }
18802
18803
18804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18805   unsigned long jresult ;
18806   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18807   size_t result;
18808
18809   arg1 = (Dali::TypeInfo *)jarg1;
18810   {
18811     try {
18812       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18813     } catch (std::out_of_range& e) {
18814       {
18815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18816       };
18817     } catch (std::exception& e) {
18818       {
18819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18820       };
18821     } catch (...) {
18822       {
18823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18824       };
18825     }
18826   }
18827   jresult = (unsigned long)result;
18828   return jresult;
18829 }
18830
18831
18832 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18833   char * jresult ;
18834   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18835   size_t arg2 ;
18836   std::string result;
18837
18838   arg1 = (Dali::TypeInfo *)jarg1;
18839   arg2 = (size_t)jarg2;
18840   {
18841     try {
18842       result = (arg1)->GetSignalName(arg2);
18843     } catch (std::out_of_range& e) {
18844       {
18845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18846       };
18847     } catch (std::exception& e) {
18848       {
18849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18850       };
18851     } catch (...) {
18852       {
18853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18854       };
18855     }
18856   }
18857   jresult = SWIG_csharp_string_callback((&result)->c_str());
18858   return jresult;
18859 }
18860
18861
18862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18863   unsigned long jresult ;
18864   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18865   size_t result;
18866
18867   arg1 = (Dali::TypeInfo *)jarg1;
18868   {
18869     try {
18870       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18871     } catch (std::out_of_range& e) {
18872       {
18873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18874       };
18875     } catch (std::exception& e) {
18876       {
18877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18878       };
18879     } catch (...) {
18880       {
18881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18882       };
18883     }
18884   }
18885   jresult = (unsigned long)result;
18886   return jresult;
18887 }
18888
18889
18890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18891   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18892   Dali::Property::IndexContainer *arg2 = 0 ;
18893
18894   arg1 = (Dali::TypeInfo *)jarg1;
18895   arg2 = (Dali::Property::IndexContainer *)jarg2;
18896   if (!arg2) {
18897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18898     return ;
18899   }
18900   {
18901     try {
18902       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18903     } catch (std::out_of_range& e) {
18904       {
18905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18906       };
18907     } catch (std::exception& e) {
18908       {
18909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18910       };
18911     } catch (...) {
18912       {
18913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18914       };
18915     }
18916   }
18917 }
18918
18919
18920 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18921   char * jresult ;
18922   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18923   Dali::Property::Index arg2 ;
18924   std::string *result = 0 ;
18925
18926   arg1 = (Dali::TypeInfo *)jarg1;
18927   arg2 = (Dali::Property::Index)jarg2;
18928   {
18929     try {
18930       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18931     } catch (std::out_of_range& e) {
18932       {
18933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18934       };
18935     } catch (std::exception& e) {
18936       {
18937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18938       };
18939     } catch (...) {
18940       {
18941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18942       };
18943     }
18944   }
18945   jresult = SWIG_csharp_string_callback(result->c_str());
18946   return jresult;
18947 }
18948
18949
18950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18951   void * jresult ;
18952   Dali::TypeRegistry result;
18953
18954   {
18955     try {
18956       result = Dali::TypeRegistry::Get();
18957     } catch (std::out_of_range& e) {
18958       {
18959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18960       };
18961     } catch (std::exception& e) {
18962       {
18963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18964       };
18965     } catch (...) {
18966       {
18967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18968       };
18969     }
18970   }
18971   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18972   return jresult;
18973 }
18974
18975
18976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18977   void * jresult ;
18978   Dali::TypeRegistry *result = 0 ;
18979
18980   {
18981     try {
18982       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18983     } catch (std::out_of_range& e) {
18984       {
18985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18986       };
18987     } catch (std::exception& e) {
18988       {
18989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18990       };
18991     } catch (...) {
18992       {
18993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18994       };
18995     }
18996   }
18997   jresult = (void *)result;
18998   return jresult;
18999 }
19000
19001
19002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19003   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19004
19005   arg1 = (Dali::TypeRegistry *)jarg1;
19006   {
19007     try {
19008       delete arg1;
19009     } catch (std::out_of_range& e) {
19010       {
19011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19012       };
19013     } catch (std::exception& e) {
19014       {
19015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19016       };
19017     } catch (...) {
19018       {
19019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19020       };
19021     }
19022   }
19023 }
19024
19025
19026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19027   void * jresult ;
19028   Dali::TypeRegistry *arg1 = 0 ;
19029   Dali::TypeRegistry *result = 0 ;
19030
19031   arg1 = (Dali::TypeRegistry *)jarg1;
19032   if (!arg1) {
19033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19034     return 0;
19035   }
19036   {
19037     try {
19038       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19039     } catch (std::out_of_range& e) {
19040       {
19041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19042       };
19043     } catch (std::exception& e) {
19044       {
19045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19050       };
19051     }
19052   }
19053   jresult = (void *)result;
19054   return jresult;
19055 }
19056
19057
19058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19059   void * jresult ;
19060   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19061   Dali::TypeRegistry *arg2 = 0 ;
19062   Dali::TypeRegistry *result = 0 ;
19063
19064   arg1 = (Dali::TypeRegistry *)jarg1;
19065   arg2 = (Dali::TypeRegistry *)jarg2;
19066   if (!arg2) {
19067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19068     return 0;
19069   }
19070   {
19071     try {
19072       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19073     } catch (std::out_of_range& e) {
19074       {
19075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19076       };
19077     } catch (std::exception& e) {
19078       {
19079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19080       };
19081     } catch (...) {
19082       {
19083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19084       };
19085     }
19086   }
19087   jresult = (void *)result;
19088   return jresult;
19089 }
19090
19091
19092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19093   void * jresult ;
19094   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19095   std::string *arg2 = 0 ;
19096   Dali::TypeInfo result;
19097
19098   arg1 = (Dali::TypeRegistry *)jarg1;
19099   if (!jarg2) {
19100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19101     return 0;
19102   }
19103   std::string arg2_str(jarg2);
19104   arg2 = &arg2_str;
19105   {
19106     try {
19107       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19108     } catch (std::out_of_range& e) {
19109       {
19110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19111       };
19112     } catch (std::exception& e) {
19113       {
19114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19115       };
19116     } catch (...) {
19117       {
19118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19119       };
19120     }
19121   }
19122   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19123
19124   //argout typemap for const std::string&
19125
19126   return jresult;
19127 }
19128
19129
19130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19131   void * jresult ;
19132   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19133   std::type_info *arg2 = 0 ;
19134   Dali::TypeInfo result;
19135
19136   arg1 = (Dali::TypeRegistry *)jarg1;
19137   arg2 = (std::type_info *)jarg2;
19138   if (!arg2) {
19139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19140     return 0;
19141   }
19142   {
19143     try {
19144       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19145     } catch (std::out_of_range& e) {
19146       {
19147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19148       };
19149     } catch (std::exception& e) {
19150       {
19151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19152       };
19153     } catch (...) {
19154       {
19155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19156       };
19157     }
19158   }
19159   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19160   return jresult;
19161 }
19162
19163
19164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19165   unsigned long jresult ;
19166   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19167   size_t result;
19168
19169   arg1 = (Dali::TypeRegistry *)jarg1;
19170   {
19171     try {
19172       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19173     } catch (std::out_of_range& e) {
19174       {
19175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19176       };
19177     } catch (std::exception& e) {
19178       {
19179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19180       };
19181     } catch (...) {
19182       {
19183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19184       };
19185     }
19186   }
19187   jresult = (unsigned long)result;
19188   return jresult;
19189 }
19190
19191
19192 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19193   char * jresult ;
19194   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19195   size_t arg2 ;
19196   std::string result;
19197
19198   arg1 = (Dali::TypeRegistry *)jarg1;
19199   arg2 = (size_t)jarg2;
19200   {
19201     try {
19202       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19203     } catch (std::out_of_range& e) {
19204       {
19205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19206       };
19207     } catch (std::exception& e) {
19208       {
19209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19210       };
19211     } catch (...) {
19212       {
19213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19214       };
19215     }
19216   }
19217   jresult = SWIG_csharp_string_callback((&result)->c_str());
19218   return jresult;
19219 }
19220
19221
19222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19223   void * jresult ;
19224   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19225   Dali::TypeRegistry *result = 0 ;
19226
19227   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19228   {
19229     try {
19230       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19231     } catch (std::out_of_range& e) {
19232       {
19233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19234       };
19235     } catch (std::exception& e) {
19236       {
19237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19238       };
19239     } catch (...) {
19240       {
19241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19242       };
19243     }
19244   }
19245   jresult = (void *)result;
19246   return jresult;
19247 }
19248
19249
19250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19251   void * jresult ;
19252   std::type_info *arg1 = 0 ;
19253   std::type_info *arg2 = 0 ;
19254   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19255   Dali::TypeRegistration *result = 0 ;
19256
19257   arg1 = (std::type_info *)jarg1;
19258   if (!arg1) {
19259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19260     return 0;
19261   }
19262   arg2 = (std::type_info *)jarg2;
19263   if (!arg2) {
19264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19265     return 0;
19266   }
19267   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19268   {
19269     try {
19270       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19271     } catch (std::out_of_range& e) {
19272       {
19273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19274       };
19275     } catch (std::exception& e) {
19276       {
19277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19278       };
19279     } catch (...) {
19280       {
19281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19282       };
19283     }
19284   }
19285   jresult = (void *)result;
19286   return jresult;
19287 }
19288
19289
19290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19291   void * jresult ;
19292   std::type_info *arg1 = 0 ;
19293   std::type_info *arg2 = 0 ;
19294   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19295   bool arg4 ;
19296   Dali::TypeRegistration *result = 0 ;
19297
19298   arg1 = (std::type_info *)jarg1;
19299   if (!arg1) {
19300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19301     return 0;
19302   }
19303   arg2 = (std::type_info *)jarg2;
19304   if (!arg2) {
19305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19306     return 0;
19307   }
19308   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19309   arg4 = jarg4 ? true : false;
19310   {
19311     try {
19312       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19313     } catch (std::out_of_range& e) {
19314       {
19315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19316       };
19317     } catch (std::exception& e) {
19318       {
19319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19320       };
19321     } catch (...) {
19322       {
19323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19324       };
19325     }
19326   }
19327   jresult = (void *)result;
19328   return jresult;
19329 }
19330
19331
19332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19333   void * jresult ;
19334   std::string *arg1 = 0 ;
19335   std::type_info *arg2 = 0 ;
19336   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19337   Dali::TypeRegistration *result = 0 ;
19338
19339   if (!jarg1) {
19340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19341     return 0;
19342   }
19343   std::string arg1_str(jarg1);
19344   arg1 = &arg1_str;
19345   arg2 = (std::type_info *)jarg2;
19346   if (!arg2) {
19347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19348     return 0;
19349   }
19350   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19351   {
19352     try {
19353       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19354     } catch (std::out_of_range& e) {
19355       {
19356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (std::exception& e) {
19359       {
19360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368   jresult = (void *)result;
19369
19370   //argout typemap for const std::string&
19371
19372   return jresult;
19373 }
19374
19375
19376 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19377   char * jresult ;
19378   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19379   std::string result;
19380
19381   arg1 = (Dali::TypeRegistration *)jarg1;
19382   {
19383     try {
19384       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19385     } catch (std::out_of_range& e) {
19386       {
19387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19388       };
19389     } catch (std::exception& e) {
19390       {
19391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19392       };
19393     } catch (...) {
19394       {
19395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19396       };
19397     }
19398   }
19399   jresult = SWIG_csharp_string_callback((&result)->c_str());
19400   return jresult;
19401 }
19402
19403
19404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19405   std::string *arg1 = 0 ;
19406   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19407
19408   if (!jarg1) {
19409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19410     return ;
19411   }
19412   std::string arg1_str(jarg1);
19413   arg1 = &arg1_str;
19414   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19415   {
19416     try {
19417       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19418     } catch (std::out_of_range& e) {
19419       {
19420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19421       };
19422     } catch (std::exception& e) {
19423       {
19424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19425       };
19426     } catch (...) {
19427       {
19428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19429       };
19430     }
19431   }
19432
19433   //argout typemap for const std::string&
19434
19435 }
19436
19437
19438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19439   std::string *arg1 = 0 ;
19440   std::string *arg2 = 0 ;
19441   int arg3 ;
19442   Dali::Property::Type arg4 ;
19443   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19444   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19445
19446   if (!jarg1) {
19447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19448     return ;
19449   }
19450   std::string arg1_str(jarg1);
19451   arg1 = &arg1_str;
19452   if (!jarg2) {
19453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19454     return ;
19455   }
19456   std::string arg2_str(jarg2);
19457   arg2 = &arg2_str;
19458   arg3 = (int)jarg3;
19459   arg4 = (Dali::Property::Type)jarg4;
19460   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19461   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19462   {
19463     try {
19464       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19465     } catch (std::out_of_range& e) {
19466       {
19467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19468       };
19469     } catch (std::exception& e) {
19470       {
19471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19472       };
19473     } catch (...) {
19474       {
19475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19476       };
19477     }
19478   }
19479
19480   //argout typemap for const std::string&
19481
19482
19483   //argout typemap for const std::string&
19484
19485 }
19486
19487
19488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19489   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19490
19491   arg1 = (Dali::TypeRegistration *)jarg1;
19492   {
19493     try {
19494       delete arg1;
19495     } catch (std::out_of_range& e) {
19496       {
19497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19498       };
19499     } catch (std::exception& e) {
19500       {
19501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19502       };
19503     } catch (...) {
19504       {
19505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19506       };
19507     }
19508   }
19509 }
19510
19511
19512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19513   void * jresult ;
19514   Dali::TypeRegistration *arg1 = 0 ;
19515   std::string *arg2 = 0 ;
19516   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19517   Dali::SignalConnectorType *result = 0 ;
19518
19519   arg1 = (Dali::TypeRegistration *)jarg1;
19520   if (!arg1) {
19521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19522     return 0;
19523   }
19524   if (!jarg2) {
19525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19526     return 0;
19527   }
19528   std::string arg2_str(jarg2);
19529   arg2 = &arg2_str;
19530   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19531   {
19532     try {
19533       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19534     } catch (std::out_of_range& e) {
19535       {
19536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (std::exception& e) {
19539       {
19540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19541       };
19542     } catch (...) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19545       };
19546     }
19547   }
19548   jresult = (void *)result;
19549
19550   //argout typemap for const std::string&
19551
19552   return jresult;
19553 }
19554
19555
19556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19557   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19558
19559   arg1 = (Dali::SignalConnectorType *)jarg1;
19560   {
19561     try {
19562       delete arg1;
19563     } catch (std::out_of_range& e) {
19564       {
19565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19566       };
19567     } catch (std::exception& e) {
19568       {
19569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19570       };
19571     } catch (...) {
19572       {
19573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19574       };
19575     }
19576   }
19577 }
19578
19579
19580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19581   void * jresult ;
19582   Dali::TypeRegistration *arg1 = 0 ;
19583   std::string *arg2 = 0 ;
19584   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19585   Dali::TypeAction *result = 0 ;
19586
19587   arg1 = (Dali::TypeRegistration *)jarg1;
19588   if (!arg1) {
19589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19590     return 0;
19591   }
19592   if (!jarg2) {
19593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19594     return 0;
19595   }
19596   std::string arg2_str(jarg2);
19597   arg2 = &arg2_str;
19598   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19599   {
19600     try {
19601       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19602     } catch (std::out_of_range& e) {
19603       {
19604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19605       };
19606     } catch (std::exception& e) {
19607       {
19608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19609       };
19610     } catch (...) {
19611       {
19612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19613       };
19614     }
19615   }
19616   jresult = (void *)result;
19617
19618   //argout typemap for const std::string&
19619
19620   return jresult;
19621 }
19622
19623
19624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19625   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19626
19627   arg1 = (Dali::TypeAction *)jarg1;
19628   {
19629     try {
19630       delete arg1;
19631     } catch (std::out_of_range& e) {
19632       {
19633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19634       };
19635     } catch (std::exception& e) {
19636       {
19637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19638       };
19639     } catch (...) {
19640       {
19641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19642       };
19643     }
19644   }
19645 }
19646
19647
19648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19649   void * jresult ;
19650   Dali::TypeRegistration *arg1 = 0 ;
19651   std::string *arg2 = 0 ;
19652   Dali::Property::Index arg3 ;
19653   Dali::Property::Type arg4 ;
19654   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19655   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19656   Dali::PropertyRegistration *result = 0 ;
19657
19658   arg1 = (Dali::TypeRegistration *)jarg1;
19659   if (!arg1) {
19660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19661     return 0;
19662   }
19663   if (!jarg2) {
19664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19665     return 0;
19666   }
19667   std::string arg2_str(jarg2);
19668   arg2 = &arg2_str;
19669   arg3 = (Dali::Property::Index)jarg3;
19670   arg4 = (Dali::Property::Type)jarg4;
19671   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19672   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19673   {
19674     try {
19675       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19676     } catch (std::out_of_range& e) {
19677       {
19678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19679       };
19680     } catch (std::exception& e) {
19681       {
19682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19683       };
19684     } catch (...) {
19685       {
19686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19687       };
19688     }
19689   }
19690   jresult = (void *)result;
19691
19692   //argout typemap for const std::string&
19693
19694   return jresult;
19695 }
19696
19697
19698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19699   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19700
19701   arg1 = (Dali::PropertyRegistration *)jarg1;
19702   {
19703     try {
19704       delete arg1;
19705     } catch (std::out_of_range& e) {
19706       {
19707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19708       };
19709     } catch (std::exception& e) {
19710       {
19711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19712       };
19713     } catch (...) {
19714       {
19715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19716       };
19717     }
19718   }
19719 }
19720
19721
19722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19723   void * jresult ;
19724   Dali::TypeRegistration *arg1 = 0 ;
19725   std::string *arg2 = 0 ;
19726   Dali::Property::Index arg3 ;
19727   Dali::Property::Type arg4 ;
19728   Dali::AnimatablePropertyRegistration *result = 0 ;
19729
19730   arg1 = (Dali::TypeRegistration *)jarg1;
19731   if (!arg1) {
19732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19733     return 0;
19734   }
19735   if (!jarg2) {
19736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19737     return 0;
19738   }
19739   std::string arg2_str(jarg2);
19740   arg2 = &arg2_str;
19741   arg3 = (Dali::Property::Index)jarg3;
19742   arg4 = (Dali::Property::Type)jarg4;
19743   {
19744     try {
19745       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19746     } catch (std::out_of_range& e) {
19747       {
19748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19749       };
19750     } catch (std::exception& e) {
19751       {
19752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19753       };
19754     } catch (...) {
19755       {
19756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19757       };
19758     }
19759   }
19760   jresult = (void *)result;
19761
19762   //argout typemap for const std::string&
19763
19764   return jresult;
19765 }
19766
19767
19768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19769   void * jresult ;
19770   Dali::TypeRegistration *arg1 = 0 ;
19771   std::string *arg2 = 0 ;
19772   Dali::Property::Index arg3 ;
19773   Dali::Property::Value *arg4 = 0 ;
19774   Dali::AnimatablePropertyRegistration *result = 0 ;
19775
19776   arg1 = (Dali::TypeRegistration *)jarg1;
19777   if (!arg1) {
19778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19779     return 0;
19780   }
19781   if (!jarg2) {
19782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19783     return 0;
19784   }
19785   std::string arg2_str(jarg2);
19786   arg2 = &arg2_str;
19787   arg3 = (Dali::Property::Index)jarg3;
19788   arg4 = (Dali::Property::Value *)jarg4;
19789   if (!arg4) {
19790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19791     return 0;
19792   }
19793   {
19794     try {
19795       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19796     } catch (std::out_of_range& e) {
19797       {
19798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19799       };
19800     } catch (std::exception& e) {
19801       {
19802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (...) {
19805       {
19806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19807       };
19808     }
19809   }
19810   jresult = (void *)result;
19811
19812   //argout typemap for const std::string&
19813
19814   return jresult;
19815 }
19816
19817
19818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19819   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19820
19821   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19822   {
19823     try {
19824       delete arg1;
19825     } catch (std::out_of_range& e) {
19826       {
19827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19828       };
19829     } catch (std::exception& e) {
19830       {
19831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19832       };
19833     } catch (...) {
19834       {
19835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19836       };
19837     }
19838   }
19839 }
19840
19841
19842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19843   void * jresult ;
19844   Dali::TypeRegistration *arg1 = 0 ;
19845   std::string *arg2 = 0 ;
19846   Dali::Property::Index arg3 ;
19847   Dali::Property::Index arg4 ;
19848   unsigned int arg5 ;
19849   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19850
19851   arg1 = (Dali::TypeRegistration *)jarg1;
19852   if (!arg1) {
19853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19854     return 0;
19855   }
19856   if (!jarg2) {
19857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19858     return 0;
19859   }
19860   std::string arg2_str(jarg2);
19861   arg2 = &arg2_str;
19862   arg3 = (Dali::Property::Index)jarg3;
19863   arg4 = (Dali::Property::Index)jarg4;
19864   arg5 = (unsigned int)jarg5;
19865   {
19866     try {
19867       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (...) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19879       };
19880     }
19881   }
19882   jresult = (void *)result;
19883
19884   //argout typemap for const std::string&
19885
19886   return jresult;
19887 }
19888
19889
19890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19891   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19892
19893   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19894   {
19895     try {
19896       delete arg1;
19897     } catch (std::out_of_range& e) {
19898       {
19899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19900       };
19901     } catch (std::exception& e) {
19902       {
19903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19904       };
19905     } catch (...) {
19906       {
19907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19908       };
19909     }
19910   }
19911 }
19912
19913
19914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19915   void * jresult ;
19916   Dali::TypeRegistration *arg1 = 0 ;
19917   std::string *arg2 = 0 ;
19918   Dali::Property::Index arg3 ;
19919   Dali::Property::Type arg4 ;
19920   Dali::ChildPropertyRegistration *result = 0 ;
19921
19922   arg1 = (Dali::TypeRegistration *)jarg1;
19923   if (!arg1) {
19924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19925     return 0;
19926   }
19927   if (!jarg2) {
19928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19929     return 0;
19930   }
19931   std::string arg2_str(jarg2);
19932   arg2 = &arg2_str;
19933   arg3 = (Dali::Property::Index)jarg3;
19934   arg4 = (Dali::Property::Type)jarg4;
19935   {
19936     try {
19937       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19938     } catch (std::out_of_range& e) {
19939       {
19940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (std::exception& e) {
19943       {
19944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952   jresult = (void *)result;
19953
19954   //argout typemap for const std::string&
19955
19956   return jresult;
19957 }
19958
19959
19960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19961   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19962
19963   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19964   {
19965     try {
19966       delete arg1;
19967     } catch (std::out_of_range& e) {
19968       {
19969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19970       };
19971     } catch (std::exception& e) {
19972       {
19973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19974       };
19975     } catch (...) {
19976       {
19977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19978       };
19979     }
19980   }
19981 }
19982
19983
19984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19985   unsigned int jresult ;
19986   std::string *arg1 = 0 ;
19987   std::type_info *arg2 = 0 ;
19988   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19989   bool result;
19990
19991   if (!jarg1) {
19992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19993     return 0;
19994   }
19995   std::string arg1_str(jarg1);
19996   arg1 = &arg1_str;
19997   arg2 = (std::type_info *)jarg2;
19998   if (!arg2) {
19999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20000     return 0;
20001   }
20002   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20003   {
20004     try {
20005       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20006     } catch (std::out_of_range& e) {
20007       {
20008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (std::exception& e) {
20011       {
20012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20013       };
20014     } catch (...) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20017       };
20018     }
20019   }
20020   jresult = result;
20021
20022   //argout typemap for const std::string&
20023
20024   return jresult;
20025 }
20026
20027
20028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20029   unsigned int jresult ;
20030   std::string *arg1 = 0 ;
20031   std::string *arg2 = 0 ;
20032   Dali::Property::Index arg3 ;
20033   Dali::Property::Type arg4 ;
20034   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20035   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20036   bool result;
20037
20038   if (!jarg1) {
20039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20040     return 0;
20041   }
20042   std::string arg1_str(jarg1);
20043   arg1 = &arg1_str;
20044   if (!jarg2) {
20045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20046     return 0;
20047   }
20048   std::string arg2_str(jarg2);
20049   arg2 = &arg2_str;
20050   arg3 = (Dali::Property::Index)jarg3;
20051   arg4 = (Dali::Property::Type)jarg4;
20052   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20053   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20054   {
20055     try {
20056       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20057     } catch (std::out_of_range& e) {
20058       {
20059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20060       };
20061     } catch (std::exception& e) {
20062       {
20063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20064       };
20065     } catch (...) {
20066       {
20067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20068       };
20069     }
20070   }
20071   jresult = result;
20072
20073   //argout typemap for const std::string&
20074
20075
20076   //argout typemap for const std::string&
20077
20078   return jresult;
20079 }
20080
20081
20082 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20083   float jresult ;
20084   float result;
20085
20086   result = (float)(float)Dali::ParentOrigin::TOP;
20087   jresult = result;
20088   return jresult;
20089 }
20090
20091
20092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20093   float jresult ;
20094   float result;
20095
20096   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20097   jresult = result;
20098   return jresult;
20099 }
20100
20101
20102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20103   float jresult ;
20104   float result;
20105
20106   result = (float)(float)Dali::ParentOrigin::LEFT;
20107   jresult = result;
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20113   float jresult ;
20114   float result;
20115
20116   result = (float)(float)Dali::ParentOrigin::RIGHT;
20117   jresult = result;
20118   return jresult;
20119 }
20120
20121
20122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20123   float jresult ;
20124   float result;
20125
20126   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20127   jresult = result;
20128   return jresult;
20129 }
20130
20131
20132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20133   void * jresult ;
20134   Dali::Vector3 *result = 0 ;
20135
20136   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20137   jresult = (void *)result;
20138   return jresult;
20139 }
20140
20141
20142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20143   void * jresult ;
20144   Dali::Vector3 *result = 0 ;
20145
20146   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20147   jresult = (void *)result;
20148   return jresult;
20149 }
20150
20151
20152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20153   void * jresult ;
20154   Dali::Vector3 *result = 0 ;
20155
20156   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20157   jresult = (void *)result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20163   void * jresult ;
20164   Dali::Vector3 *result = 0 ;
20165
20166   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20167   jresult = (void *)result;
20168   return jresult;
20169 }
20170
20171
20172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20173   void * jresult ;
20174   Dali::Vector3 *result = 0 ;
20175
20176   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20177   jresult = (void *)result;
20178   return jresult;
20179 }
20180
20181
20182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20183   void * jresult ;
20184   Dali::Vector3 *result = 0 ;
20185
20186   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20187   jresult = (void *)result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20193   void * jresult ;
20194   Dali::Vector3 *result = 0 ;
20195
20196   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20197   jresult = (void *)result;
20198   return jresult;
20199 }
20200
20201
20202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20203   void * jresult ;
20204   Dali::Vector3 *result = 0 ;
20205
20206   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20207   jresult = (void *)result;
20208   return jresult;
20209 }
20210
20211
20212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20213   void * jresult ;
20214   Dali::Vector3 *result = 0 ;
20215
20216   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20217   jresult = (void *)result;
20218   return jresult;
20219 }
20220
20221
20222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20223   float jresult ;
20224   float result;
20225
20226   result = (float)(float)Dali::AnchorPoint::TOP;
20227   jresult = result;
20228   return jresult;
20229 }
20230
20231
20232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20233   float jresult ;
20234   float result;
20235
20236   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20237   jresult = result;
20238   return jresult;
20239 }
20240
20241
20242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20243   float jresult ;
20244   float result;
20245
20246   result = (float)(float)Dali::AnchorPoint::LEFT;
20247   jresult = result;
20248   return jresult;
20249 }
20250
20251
20252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20253   float jresult ;
20254   float result;
20255
20256   result = (float)(float)Dali::AnchorPoint::RIGHT;
20257   jresult = result;
20258   return jresult;
20259 }
20260
20261
20262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20263   float jresult ;
20264   float result;
20265
20266   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20267   jresult = result;
20268   return jresult;
20269 }
20270
20271
20272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20273   void * jresult ;
20274   Dali::Vector3 *result = 0 ;
20275
20276   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20277   jresult = (void *)result;
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20283   void * jresult ;
20284   Dali::Vector3 *result = 0 ;
20285
20286   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20287   jresult = (void *)result;
20288   return jresult;
20289 }
20290
20291
20292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20293   void * jresult ;
20294   Dali::Vector3 *result = 0 ;
20295
20296   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20297   jresult = (void *)result;
20298   return jresult;
20299 }
20300
20301
20302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20303   void * jresult ;
20304   Dali::Vector3 *result = 0 ;
20305
20306   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20307   jresult = (void *)result;
20308   return jresult;
20309 }
20310
20311
20312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20313   void * jresult ;
20314   Dali::Vector3 *result = 0 ;
20315
20316   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20317   jresult = (void *)result;
20318   return jresult;
20319 }
20320
20321
20322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20323   void * jresult ;
20324   Dali::Vector3 *result = 0 ;
20325
20326   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20327   jresult = (void *)result;
20328   return jresult;
20329 }
20330
20331
20332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20333   void * jresult ;
20334   Dali::Vector3 *result = 0 ;
20335
20336   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20337   jresult = (void *)result;
20338   return jresult;
20339 }
20340
20341
20342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20343   void * jresult ;
20344   Dali::Vector3 *result = 0 ;
20345
20346   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20347   jresult = (void *)result;
20348   return jresult;
20349 }
20350
20351
20352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20353   void * jresult ;
20354   Dali::Vector3 *result = 0 ;
20355
20356   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20357   jresult = (void *)result;
20358   return jresult;
20359 }
20360
20361
20362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20363   void * jresult ;
20364   Dali::Vector4 *result = 0 ;
20365
20366   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20367   jresult = (void *)result;
20368   return jresult;
20369 }
20370
20371
20372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20373   void * jresult ;
20374   Dali::Vector4 *result = 0 ;
20375
20376   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20377   jresult = (void *)result;
20378   return jresult;
20379 }
20380
20381
20382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20383   void * jresult ;
20384   Dali::Vector4 *result = 0 ;
20385
20386   result = (Dali::Vector4 *)&Dali::Color::RED;
20387   jresult = (void *)result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20393   void * jresult ;
20394   Dali::Vector4 *result = 0 ;
20395
20396   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20397   jresult = (void *)result;
20398   return jresult;
20399 }
20400
20401
20402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20403   void * jresult ;
20404   Dali::Vector4 *result = 0 ;
20405
20406   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20407   jresult = (void *)result;
20408   return jresult;
20409 }
20410
20411
20412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20413   void * jresult ;
20414   Dali::Vector4 *result = 0 ;
20415
20416   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20417   jresult = (void *)result;
20418   return jresult;
20419 }
20420
20421
20422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20423   void * jresult ;
20424   Dali::Vector4 *result = 0 ;
20425
20426   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20427   jresult = (void *)result;
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20433   void * jresult ;
20434   Dali::Vector4 *result = 0 ;
20435
20436   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20437   jresult = (void *)result;
20438   return jresult;
20439 }
20440
20441
20442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20443   void * jresult ;
20444   Dali::Vector4 *result = 0 ;
20445
20446   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20447   jresult = (void *)result;
20448   return jresult;
20449 }
20450
20451
20452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20453   float jresult ;
20454   float result;
20455
20456   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20457   jresult = result;
20458   return jresult;
20459 }
20460
20461
20462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20463   float jresult ;
20464   float result;
20465
20466   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20467   jresult = result;
20468   return jresult;
20469 }
20470
20471
20472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20473   float jresult ;
20474   float result;
20475
20476   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20477   jresult = result;
20478   return jresult;
20479 }
20480
20481
20482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20483   float jresult ;
20484   float result;
20485
20486   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20487   jresult = result;
20488   return jresult;
20489 }
20490
20491
20492 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20493   float jresult ;
20494   float result;
20495
20496   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20497   jresult = result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20503   float jresult ;
20504   float result;
20505
20506   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20507   jresult = result;
20508   return jresult;
20509 }
20510
20511
20512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20513   float jresult ;
20514   float result;
20515
20516   result = (float)(float)Dali::Math::PI;
20517   jresult = result;
20518   return jresult;
20519 }
20520
20521
20522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20523   float jresult ;
20524   float result;
20525
20526   result = (float)(float)Dali::Math::PI_2;
20527   jresult = result;
20528   return jresult;
20529 }
20530
20531
20532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20533   float jresult ;
20534   float result;
20535
20536   result = (float)(float)Dali::Math::PI_4;
20537   jresult = result;
20538   return jresult;
20539 }
20540
20541
20542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20543   float jresult ;
20544   float result;
20545
20546   result = (float)(float)Dali::Math::PI_OVER_180;
20547   jresult = result;
20548   return jresult;
20549 }
20550
20551
20552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20553   float jresult ;
20554   float result;
20555
20556   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20557   jresult = result;
20558   return jresult;
20559 }
20560
20561
20562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20563   int jresult ;
20564   Dali::ResizePolicy::Type result;
20565
20566   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20567   jresult = (int)result;
20568   return jresult;
20569 }
20570
20571
20572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20573   unsigned long jresult ;
20574   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20575   Dali::VectorBase::SizeType result;
20576
20577   arg1 = (Dali::VectorBase *)jarg1;
20578   {
20579     try {
20580       result = ((Dali::VectorBase const *)arg1)->Count();
20581     } catch (std::out_of_range& e) {
20582       {
20583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20584       };
20585     } catch (std::exception& e) {
20586       {
20587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20588       };
20589     } catch (...) {
20590       {
20591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20592       };
20593     }
20594   }
20595   jresult = (unsigned long)result;
20596   return jresult;
20597 }
20598
20599
20600 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20601   unsigned long jresult ;
20602   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20603   Dali::VectorBase::SizeType result;
20604
20605   arg1 = (Dali::VectorBase *)jarg1;
20606   {
20607     try {
20608       result = ((Dali::VectorBase const *)arg1)->Size();
20609     } catch (std::out_of_range& e) {
20610       {
20611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20612       };
20613     } catch (std::exception& e) {
20614       {
20615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20616       };
20617     } catch (...) {
20618       {
20619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20620       };
20621     }
20622   }
20623   jresult = (unsigned long)result;
20624   return jresult;
20625 }
20626
20627
20628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20629   unsigned int jresult ;
20630   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20631   bool result;
20632
20633   arg1 = (Dali::VectorBase *)jarg1;
20634   {
20635     try {
20636       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20637     } catch (std::out_of_range& e) {
20638       {
20639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20640       };
20641     } catch (std::exception& e) {
20642       {
20643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20644       };
20645     } catch (...) {
20646       {
20647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20648       };
20649     }
20650   }
20651   jresult = result;
20652   return jresult;
20653 }
20654
20655
20656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20657   unsigned long jresult ;
20658   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20659   Dali::VectorBase::SizeType result;
20660
20661   arg1 = (Dali::VectorBase *)jarg1;
20662   {
20663     try {
20664       result = ((Dali::VectorBase const *)arg1)->Capacity();
20665     } catch (std::out_of_range& e) {
20666       {
20667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (std::exception& e) {
20670       {
20671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679   jresult = (unsigned long)result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20685   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20686
20687   arg1 = (Dali::VectorBase *)jarg1;
20688   {
20689     try {
20690       (arg1)->Release();
20691     } catch (std::out_of_range& e) {
20692       {
20693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20694       };
20695     } catch (std::exception& e) {
20696       {
20697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20698       };
20699     } catch (...) {
20700       {
20701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20702       };
20703     }
20704   }
20705 }
20706
20707
20708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20709   void * jresult ;
20710   Dali::Image *result = 0 ;
20711
20712   {
20713     try {
20714       result = (Dali::Image *)new Dali::Image();
20715     } catch (std::out_of_range& e) {
20716       {
20717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20718       };
20719     } catch (std::exception& e) {
20720       {
20721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20722       };
20723     } catch (...) {
20724       {
20725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20726       };
20727     }
20728   }
20729   jresult = (void *)result;
20730   return jresult;
20731 }
20732
20733
20734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20735   Dali::Image *arg1 = (Dali::Image *) 0 ;
20736
20737   arg1 = (Dali::Image *)jarg1;
20738   {
20739     try {
20740       delete arg1;
20741     } catch (std::out_of_range& e) {
20742       {
20743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20744       };
20745     } catch (std::exception& e) {
20746       {
20747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20748       };
20749     } catch (...) {
20750       {
20751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20752       };
20753     }
20754   }
20755 }
20756
20757
20758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20759   void * jresult ;
20760   Dali::Image *arg1 = 0 ;
20761   Dali::Image *result = 0 ;
20762
20763   arg1 = (Dali::Image *)jarg1;
20764   if (!arg1) {
20765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20766     return 0;
20767   }
20768   {
20769     try {
20770       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20771     } catch (std::out_of_range& e) {
20772       {
20773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20774       };
20775     } catch (std::exception& e) {
20776       {
20777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20778       };
20779     } catch (...) {
20780       {
20781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20782       };
20783     }
20784   }
20785   jresult = (void *)result;
20786   return jresult;
20787 }
20788
20789
20790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20791   void * jresult ;
20792   Dali::Image *arg1 = (Dali::Image *) 0 ;
20793   Dali::Image *arg2 = 0 ;
20794   Dali::Image *result = 0 ;
20795
20796   arg1 = (Dali::Image *)jarg1;
20797   arg2 = (Dali::Image *)jarg2;
20798   if (!arg2) {
20799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20800     return 0;
20801   }
20802   {
20803     try {
20804       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20805     } catch (std::out_of_range& e) {
20806       {
20807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20808       };
20809     } catch (std::exception& e) {
20810       {
20811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20812       };
20813     } catch (...) {
20814       {
20815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20816       };
20817     }
20818   }
20819   jresult = (void *)result;
20820   return jresult;
20821 }
20822
20823
20824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20825   void * jresult ;
20826   Dali::BaseHandle arg1 ;
20827   Dali::BaseHandle *argp1 ;
20828   Dali::Image result;
20829
20830   argp1 = (Dali::BaseHandle *)jarg1;
20831   if (!argp1) {
20832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20833     return 0;
20834   }
20835   arg1 = *argp1;
20836   {
20837     try {
20838       result = Dali::Image::DownCast(arg1);
20839     } catch (std::out_of_range& e) {
20840       {
20841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20842       };
20843     } catch (std::exception& e) {
20844       {
20845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20846       };
20847     } catch (...) {
20848       {
20849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20850       };
20851     }
20852   }
20853   jresult = new Dali::Image((const Dali::Image &)result);
20854   return jresult;
20855 }
20856
20857
20858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20859   unsigned int jresult ;
20860   Dali::Image *arg1 = (Dali::Image *) 0 ;
20861   unsigned int result;
20862
20863   arg1 = (Dali::Image *)jarg1;
20864   {
20865     try {
20866       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20867     } catch (std::out_of_range& e) {
20868       {
20869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20870       };
20871     } catch (std::exception& e) {
20872       {
20873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20874       };
20875     } catch (...) {
20876       {
20877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20878       };
20879     }
20880   }
20881   jresult = result;
20882   return jresult;
20883 }
20884
20885
20886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20887   unsigned int jresult ;
20888   Dali::Image *arg1 = (Dali::Image *) 0 ;
20889   unsigned int result;
20890
20891   arg1 = (Dali::Image *)jarg1;
20892   {
20893     try {
20894       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20895     } catch (std::out_of_range& e) {
20896       {
20897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20898       };
20899     } catch (std::exception& e) {
20900       {
20901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20902       };
20903     } catch (...) {
20904       {
20905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20906       };
20907     }
20908   }
20909   jresult = result;
20910   return jresult;
20911 }
20912
20913
20914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20915   void * jresult ;
20916   Dali::Image *arg1 = (Dali::Image *) 0 ;
20917   Dali::Image::ImageSignalType *result = 0 ;
20918
20919   arg1 = (Dali::Image *)jarg1;
20920   {
20921     try {
20922       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20923     } catch (std::out_of_range& e) {
20924       {
20925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20926       };
20927     } catch (std::exception& e) {
20928       {
20929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20930       };
20931     } catch (...) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20934       };
20935     }
20936   }
20937   jresult = (void *)result;
20938   return jresult;
20939 }
20940
20941
20942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20943   int jresult ;
20944   Dali::Pixel::Format result;
20945
20946   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20947   jresult = (int)result;
20948   return jresult;
20949 }
20950
20951
20952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20953   int jresult ;
20954   Dali::Pixel::Format result;
20955
20956   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20957   jresult = (int)result;
20958   return jresult;
20959 }
20960
20961
20962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20963   unsigned int jresult ;
20964   Dali::Pixel::Format arg1 ;
20965   bool result;
20966
20967   arg1 = (Dali::Pixel::Format)jarg1;
20968   {
20969     try {
20970       result = (bool)Dali::Pixel::HasAlpha(arg1);
20971     } catch (std::out_of_range& e) {
20972       {
20973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20974       };
20975     } catch (std::exception& e) {
20976       {
20977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20978       };
20979     } catch (...) {
20980       {
20981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20982       };
20983     }
20984   }
20985   jresult = result;
20986   return jresult;
20987 }
20988
20989
20990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20991   unsigned int jresult ;
20992   Dali::Pixel::Format arg1 ;
20993   unsigned int result;
20994
20995   arg1 = (Dali::Pixel::Format)jarg1;
20996   {
20997     try {
20998       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20999     } catch (std::out_of_range& e) {
21000       {
21001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21002       };
21003     } catch (std::exception& e) {
21004       {
21005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21006       };
21007     } catch (...) {
21008       {
21009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21010       };
21011     }
21012   }
21013   jresult = result;
21014   return jresult;
21015 }
21016
21017
21018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21019   Dali::Pixel::Format arg1 ;
21020   int *arg2 = 0 ;
21021   int *arg3 = 0 ;
21022
21023   arg1 = (Dali::Pixel::Format)jarg1;
21024   arg2 = (int *)jarg2;
21025   if (!arg2) {
21026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21027     return ;
21028   }
21029   arg3 = (int *)jarg3;
21030   if (!arg3) {
21031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21032     return ;
21033   }
21034   {
21035     try {
21036       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21037     } catch (std::out_of_range& e) {
21038       {
21039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21040       };
21041     } catch (std::exception& e) {
21042       {
21043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21044       };
21045     } catch (...) {
21046       {
21047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21048       };
21049     }
21050   }
21051 }
21052
21053
21054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21055   void * jresult ;
21056   unsigned char *arg1 = (unsigned char *) 0 ;
21057   unsigned int arg2 ;
21058   unsigned int arg3 ;
21059   unsigned int arg4 ;
21060   Dali::Pixel::Format arg5 ;
21061   Dali::PixelData::ReleaseFunction arg6 ;
21062   Dali::PixelData result;
21063
21064   arg1 = jarg1;
21065   arg2 = (unsigned int)jarg2;
21066   arg3 = (unsigned int)jarg3;
21067   arg4 = (unsigned int)jarg4;
21068   arg5 = (Dali::Pixel::Format)jarg5;
21069   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21070   {
21071     try {
21072       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21073     } catch (std::out_of_range& e) {
21074       {
21075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21076       };
21077     } catch (std::exception& e) {
21078       {
21079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21080       };
21081     } catch (...) {
21082       {
21083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21084       };
21085     }
21086   }
21087   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21088
21089
21090   return jresult;
21091 }
21092
21093
21094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21095   void * jresult ;
21096   Dali::PixelData *result = 0 ;
21097
21098   {
21099     try {
21100       result = (Dali::PixelData *)new Dali::PixelData();
21101     } catch (std::out_of_range& e) {
21102       {
21103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21104       };
21105     } catch (std::exception& e) {
21106       {
21107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21108       };
21109     } catch (...) {
21110       {
21111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21112       };
21113     }
21114   }
21115   jresult = (void *)result;
21116   return jresult;
21117 }
21118
21119
21120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21121   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21122
21123   arg1 = (Dali::PixelData *)jarg1;
21124   {
21125     try {
21126       delete arg1;
21127     } catch (std::out_of_range& e) {
21128       {
21129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21130       };
21131     } catch (std::exception& e) {
21132       {
21133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21134       };
21135     } catch (...) {
21136       {
21137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21138       };
21139     }
21140   }
21141 }
21142
21143
21144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21145   void * jresult ;
21146   Dali::PixelData *arg1 = 0 ;
21147   Dali::PixelData *result = 0 ;
21148
21149   arg1 = (Dali::PixelData *)jarg1;
21150   if (!arg1) {
21151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21152     return 0;
21153   }
21154   {
21155     try {
21156       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21157     } catch (std::out_of_range& e) {
21158       {
21159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21160       };
21161     } catch (std::exception& e) {
21162       {
21163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21164       };
21165     } catch (...) {
21166       {
21167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21168       };
21169     }
21170   }
21171   jresult = (void *)result;
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21177   void * jresult ;
21178   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21179   Dali::PixelData *arg2 = 0 ;
21180   Dali::PixelData *result = 0 ;
21181
21182   arg1 = (Dali::PixelData *)jarg1;
21183   arg2 = (Dali::PixelData *)jarg2;
21184   if (!arg2) {
21185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21186     return 0;
21187   }
21188   {
21189     try {
21190       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21191     } catch (std::out_of_range& e) {
21192       {
21193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21194       };
21195     } catch (std::exception& e) {
21196       {
21197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21198       };
21199     } catch (...) {
21200       {
21201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21202       };
21203     }
21204   }
21205   jresult = (void *)result;
21206   return jresult;
21207 }
21208
21209
21210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21211   unsigned int jresult ;
21212   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21213   unsigned int result;
21214
21215   arg1 = (Dali::PixelData *)jarg1;
21216   {
21217     try {
21218       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21219     } catch (std::out_of_range& e) {
21220       {
21221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21222       };
21223     } catch (std::exception& e) {
21224       {
21225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21226       };
21227     } catch (...) {
21228       {
21229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21230       };
21231     }
21232   }
21233   jresult = result;
21234   return jresult;
21235 }
21236
21237
21238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21239   unsigned int jresult ;
21240   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21241   unsigned int result;
21242
21243   arg1 = (Dali::PixelData *)jarg1;
21244   {
21245     try {
21246       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21247     } catch (std::out_of_range& e) {
21248       {
21249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21250       };
21251     } catch (std::exception& e) {
21252       {
21253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (...) {
21256       {
21257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21258       };
21259     }
21260   }
21261   jresult = result;
21262   return jresult;
21263 }
21264
21265
21266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21267   int jresult ;
21268   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21269   Dali::Pixel::Format result;
21270
21271   arg1 = (Dali::PixelData *)jarg1;
21272   {
21273     try {
21274       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21275     } catch (std::out_of_range& e) {
21276       {
21277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21278       };
21279     } catch (std::exception& e) {
21280       {
21281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21282       };
21283     } catch (...) {
21284       {
21285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21286       };
21287     }
21288   }
21289   jresult = (int)result;
21290   return jresult;
21291 }
21292
21293
21294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21295   unsigned int jresult ;
21296   unsigned int result;
21297
21298   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21299   jresult = result;
21300   return jresult;
21301 }
21302
21303
21304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21305   unsigned int jresult ;
21306   unsigned int result;
21307
21308   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21309   jresult = result;
21310   return jresult;
21311 }
21312
21313
21314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21315   unsigned int jresult ;
21316   unsigned int result;
21317
21318   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21319   jresult = result;
21320   return jresult;
21321 }
21322
21323
21324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21325   unsigned int jresult ;
21326   unsigned int result;
21327
21328   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21329   jresult = result;
21330   return jresult;
21331 }
21332
21333
21334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21335   unsigned int jresult ;
21336   unsigned int result;
21337
21338   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21339   jresult = result;
21340   return jresult;
21341 }
21342
21343
21344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21345   unsigned int jresult ;
21346   unsigned int result;
21347
21348   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21349   jresult = result;
21350   return jresult;
21351 }
21352
21353
21354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21355   void * jresult ;
21356   Dali::TextureType::Type arg1 ;
21357   Dali::Pixel::Format arg2 ;
21358   unsigned int arg3 ;
21359   unsigned int arg4 ;
21360   Dali::Texture result;
21361
21362   arg1 = (Dali::TextureType::Type)jarg1;
21363   arg2 = (Dali::Pixel::Format)jarg2;
21364   arg3 = (unsigned int)jarg3;
21365   arg4 = (unsigned int)jarg4;
21366   {
21367     try {
21368       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21369     } catch (std::out_of_range& e) {
21370       {
21371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21372       };
21373     } catch (std::exception& e) {
21374       {
21375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21376       };
21377     } catch (...) {
21378       {
21379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21380       };
21381     }
21382   }
21383   jresult = new Dali::Texture((const Dali::Texture &)result);
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21389   void * jresult ;
21390   NativeImageInterface *arg1 = 0 ;
21391   Dali::Texture result;
21392
21393   arg1 = (NativeImageInterface *)jarg1;
21394   if (!arg1) {
21395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21396     return 0;
21397   }
21398   {
21399     try {
21400       result = Dali::Texture::New(*arg1);
21401     } catch (std::out_of_range& e) {
21402       {
21403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21404       };
21405     } catch (std::exception& e) {
21406       {
21407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21408       };
21409     } catch (...) {
21410       {
21411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21412       };
21413     }
21414   }
21415   jresult = new Dali::Texture((const Dali::Texture &)result);
21416   return jresult;
21417 }
21418
21419
21420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21421   void * jresult ;
21422   Dali::Texture *result = 0 ;
21423
21424   {
21425     try {
21426       result = (Dali::Texture *)new Dali::Texture();
21427     } catch (std::out_of_range& e) {
21428       {
21429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21430       };
21431     } catch (std::exception& e) {
21432       {
21433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21434       };
21435     } catch (...) {
21436       {
21437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21438       };
21439     }
21440   }
21441   jresult = (void *)result;
21442   return jresult;
21443 }
21444
21445
21446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21447   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21448
21449   arg1 = (Dali::Texture *)jarg1;
21450   {
21451     try {
21452       delete arg1;
21453     } catch (std::out_of_range& e) {
21454       {
21455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21456       };
21457     } catch (std::exception& e) {
21458       {
21459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21460       };
21461     } catch (...) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21464       };
21465     }
21466   }
21467 }
21468
21469
21470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21471   void * jresult ;
21472   Dali::Texture *arg1 = 0 ;
21473   Dali::Texture *result = 0 ;
21474
21475   arg1 = (Dali::Texture *)jarg1;
21476   if (!arg1) {
21477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21478     return 0;
21479   }
21480   {
21481     try {
21482       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21483     } catch (std::out_of_range& e) {
21484       {
21485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21486       };
21487     } catch (std::exception& e) {
21488       {
21489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (...) {
21492       {
21493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21494       };
21495     }
21496   }
21497   jresult = (void *)result;
21498   return jresult;
21499 }
21500
21501
21502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21503   void * jresult ;
21504   Dali::BaseHandle arg1 ;
21505   Dali::BaseHandle *argp1 ;
21506   Dali::Texture result;
21507
21508   argp1 = (Dali::BaseHandle *)jarg1;
21509   if (!argp1) {
21510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21511     return 0;
21512   }
21513   arg1 = *argp1;
21514   {
21515     try {
21516       result = Dali::Texture::DownCast(arg1);
21517     } catch (std::out_of_range& e) {
21518       {
21519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21520       };
21521     } catch (std::exception& e) {
21522       {
21523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21524       };
21525     } catch (...) {
21526       {
21527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21528       };
21529     }
21530   }
21531   jresult = new Dali::Texture((const Dali::Texture &)result);
21532   return jresult;
21533 }
21534
21535
21536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21537   void * jresult ;
21538   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21539   Dali::Texture *arg2 = 0 ;
21540   Dali::Texture *result = 0 ;
21541
21542   arg1 = (Dali::Texture *)jarg1;
21543   arg2 = (Dali::Texture *)jarg2;
21544   if (!arg2) {
21545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21546     return 0;
21547   }
21548   {
21549     try {
21550       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21551     } catch (std::out_of_range& e) {
21552       {
21553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21554       };
21555     } catch (std::exception& e) {
21556       {
21557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21558       };
21559     } catch (...) {
21560       {
21561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21562       };
21563     }
21564   }
21565   jresult = (void *)result;
21566   return jresult;
21567 }
21568
21569
21570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21571   unsigned int jresult ;
21572   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21573   Dali::PixelData arg2 ;
21574   Dali::PixelData *argp2 ;
21575   bool result;
21576
21577   arg1 = (Dali::Texture *)jarg1;
21578   argp2 = (Dali::PixelData *)jarg2;
21579   if (!argp2) {
21580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21581     return 0;
21582   }
21583   arg2 = *argp2;
21584   {
21585     try {
21586       result = (bool)(arg1)->Upload(arg2);
21587     } catch (std::out_of_range& e) {
21588       {
21589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21590       };
21591     } catch (std::exception& e) {
21592       {
21593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21594       };
21595     } catch (...) {
21596       {
21597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21598       };
21599     }
21600   }
21601   jresult = result;
21602   return jresult;
21603 }
21604
21605
21606 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) {
21607   unsigned int jresult ;
21608   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21609   Dali::PixelData arg2 ;
21610   unsigned int arg3 ;
21611   unsigned int arg4 ;
21612   unsigned int arg5 ;
21613   unsigned int arg6 ;
21614   unsigned int arg7 ;
21615   unsigned int arg8 ;
21616   Dali::PixelData *argp2 ;
21617   bool result;
21618
21619   arg1 = (Dali::Texture *)jarg1;
21620   argp2 = (Dali::PixelData *)jarg2;
21621   if (!argp2) {
21622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21623     return 0;
21624   }
21625   arg2 = *argp2;
21626   arg3 = (unsigned int)jarg3;
21627   arg4 = (unsigned int)jarg4;
21628   arg5 = (unsigned int)jarg5;
21629   arg6 = (unsigned int)jarg6;
21630   arg7 = (unsigned int)jarg7;
21631   arg8 = (unsigned int)jarg8;
21632   {
21633     try {
21634       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21635     } catch (std::out_of_range& e) {
21636       {
21637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21638       };
21639     } catch (std::exception& e) {
21640       {
21641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21642       };
21643     } catch (...) {
21644       {
21645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21646       };
21647     }
21648   }
21649   jresult = result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21655   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21656
21657   arg1 = (Dali::Texture *)jarg1;
21658   {
21659     try {
21660       (arg1)->GenerateMipmaps();
21661     } catch (std::out_of_range& e) {
21662       {
21663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21664       };
21665     } catch (std::exception& e) {
21666       {
21667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21668       };
21669     } catch (...) {
21670       {
21671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21672       };
21673     }
21674   }
21675 }
21676
21677
21678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21679   unsigned int jresult ;
21680   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21681   unsigned int result;
21682
21683   arg1 = (Dali::Texture *)jarg1;
21684   {
21685     try {
21686       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21687     } catch (std::out_of_range& e) {
21688       {
21689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21690       };
21691     } catch (std::exception& e) {
21692       {
21693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21694       };
21695     } catch (...) {
21696       {
21697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21698       };
21699     }
21700   }
21701   jresult = result;
21702   return jresult;
21703 }
21704
21705
21706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21707   unsigned int jresult ;
21708   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21709   unsigned int result;
21710
21711   arg1 = (Dali::Texture *)jarg1;
21712   {
21713     try {
21714       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21715     } catch (std::out_of_range& e) {
21716       {
21717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21718       };
21719     } catch (std::exception& e) {
21720       {
21721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21722       };
21723     } catch (...) {
21724       {
21725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21726       };
21727     }
21728   }
21729   jresult = result;
21730   return jresult;
21731 }
21732
21733
21734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21735   void * jresult ;
21736   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21737   Dali::Texture *result = 0 ;
21738
21739   arg1 = (Dali::Internal::Texture *)jarg1;
21740   {
21741     try {
21742       result = (Dali::Texture *)new Dali::Texture(arg1);
21743     } catch (std::out_of_range& e) {
21744       {
21745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21746       };
21747     } catch (std::exception& e) {
21748       {
21749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21750       };
21751     } catch (...) {
21752       {
21753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21754       };
21755     }
21756   }
21757   jresult = (void *)result;
21758   return jresult;
21759 }
21760
21761
21762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21763   void * jresult ;
21764   Dali::Sampler result;
21765
21766   {
21767     try {
21768       result = Dali::Sampler::New();
21769     } catch (std::out_of_range& e) {
21770       {
21771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21772       };
21773     } catch (std::exception& e) {
21774       {
21775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21776       };
21777     } catch (...) {
21778       {
21779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21780       };
21781     }
21782   }
21783   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21784   return jresult;
21785 }
21786
21787
21788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21789   void * jresult ;
21790   Dali::Sampler *result = 0 ;
21791
21792   {
21793     try {
21794       result = (Dali::Sampler *)new Dali::Sampler();
21795     } catch (std::out_of_range& e) {
21796       {
21797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (std::exception& e) {
21800       {
21801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (...) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21806       };
21807     }
21808   }
21809   jresult = (void *)result;
21810   return jresult;
21811 }
21812
21813
21814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21815   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21816
21817   arg1 = (Dali::Sampler *)jarg1;
21818   {
21819     try {
21820       delete arg1;
21821     } catch (std::out_of_range& e) {
21822       {
21823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21824       };
21825     } catch (std::exception& e) {
21826       {
21827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21828       };
21829     } catch (...) {
21830       {
21831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21832       };
21833     }
21834   }
21835 }
21836
21837
21838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21839   void * jresult ;
21840   Dali::Sampler *arg1 = 0 ;
21841   Dali::Sampler *result = 0 ;
21842
21843   arg1 = (Dali::Sampler *)jarg1;
21844   if (!arg1) {
21845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21846     return 0;
21847   }
21848   {
21849     try {
21850       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21851     } catch (std::out_of_range& e) {
21852       {
21853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21854       };
21855     } catch (std::exception& e) {
21856       {
21857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21858       };
21859     } catch (...) {
21860       {
21861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21862       };
21863     }
21864   }
21865   jresult = (void *)result;
21866   return jresult;
21867 }
21868
21869
21870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21871   void * jresult ;
21872   Dali::BaseHandle arg1 ;
21873   Dali::BaseHandle *argp1 ;
21874   Dali::Sampler result;
21875
21876   argp1 = (Dali::BaseHandle *)jarg1;
21877   if (!argp1) {
21878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21879     return 0;
21880   }
21881   arg1 = *argp1;
21882   {
21883     try {
21884       result = Dali::Sampler::DownCast(arg1);
21885     } catch (std::out_of_range& e) {
21886       {
21887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21888       };
21889     } catch (std::exception& e) {
21890       {
21891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21892       };
21893     } catch (...) {
21894       {
21895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21896       };
21897     }
21898   }
21899   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21900   return jresult;
21901 }
21902
21903
21904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21905   void * jresult ;
21906   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21907   Dali::Sampler *arg2 = 0 ;
21908   Dali::Sampler *result = 0 ;
21909
21910   arg1 = (Dali::Sampler *)jarg1;
21911   arg2 = (Dali::Sampler *)jarg2;
21912   if (!arg2) {
21913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21914     return 0;
21915   }
21916   {
21917     try {
21918       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21919     } catch (std::out_of_range& e) {
21920       {
21921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21922       };
21923     } catch (std::exception& e) {
21924       {
21925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21926       };
21927     } catch (...) {
21928       {
21929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21930       };
21931     }
21932   }
21933   jresult = (void *)result;
21934   return jresult;
21935 }
21936
21937
21938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21939   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21940   Dali::FilterMode::Type arg2 ;
21941   Dali::FilterMode::Type arg3 ;
21942
21943   arg1 = (Dali::Sampler *)jarg1;
21944   arg2 = (Dali::FilterMode::Type)jarg2;
21945   arg3 = (Dali::FilterMode::Type)jarg3;
21946   {
21947     try {
21948       (arg1)->SetFilterMode(arg2,arg3);
21949     } catch (std::out_of_range& e) {
21950       {
21951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21952       };
21953     } catch (std::exception& e) {
21954       {
21955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21960       };
21961     }
21962   }
21963 }
21964
21965
21966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21967   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21968   Dali::WrapMode::Type arg2 ;
21969   Dali::WrapMode::Type arg3 ;
21970
21971   arg1 = (Dali::Sampler *)jarg1;
21972   arg2 = (Dali::WrapMode::Type)jarg2;
21973   arg3 = (Dali::WrapMode::Type)jarg3;
21974   {
21975     try {
21976       (arg1)->SetWrapMode(arg2,arg3);
21977     } catch (std::out_of_range& e) {
21978       {
21979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21980       };
21981     } catch (std::exception& e) {
21982       {
21983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21984       };
21985     } catch (...) {
21986       {
21987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21988       };
21989     }
21990   }
21991 }
21992
21993
21994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21995   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21996   Dali::WrapMode::Type arg2 ;
21997   Dali::WrapMode::Type arg3 ;
21998   Dali::WrapMode::Type arg4 ;
21999
22000   arg1 = (Dali::Sampler *)jarg1;
22001   arg2 = (Dali::WrapMode::Type)jarg2;
22002   arg3 = (Dali::WrapMode::Type)jarg3;
22003   arg4 = (Dali::WrapMode::Type)jarg4;
22004   {
22005     try {
22006       (arg1)->SetWrapMode(arg2,arg3,arg4);
22007     } catch (std::out_of_range& e) {
22008       {
22009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22010       };
22011     } catch (std::exception& e) {
22012       {
22013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22014       };
22015     } catch (...) {
22016       {
22017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22018       };
22019     }
22020   }
22021 }
22022
22023
22024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22025   void * jresult ;
22026   Dali::TextureSet result;
22027
22028   {
22029     try {
22030       result = Dali::TextureSet::New();
22031     } catch (std::out_of_range& e) {
22032       {
22033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22034       };
22035     } catch (std::exception& e) {
22036       {
22037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22038       };
22039     } catch (...) {
22040       {
22041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22042       };
22043     }
22044   }
22045   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22046   return jresult;
22047 }
22048
22049
22050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22051   void * jresult ;
22052   Dali::TextureSet *result = 0 ;
22053
22054   {
22055     try {
22056       result = (Dali::TextureSet *)new Dali::TextureSet();
22057     } catch (std::out_of_range& e) {
22058       {
22059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22060       };
22061     } catch (std::exception& e) {
22062       {
22063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22064       };
22065     } catch (...) {
22066       {
22067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22068       };
22069     }
22070   }
22071   jresult = (void *)result;
22072   return jresult;
22073 }
22074
22075
22076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22077   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22078
22079   arg1 = (Dali::TextureSet *)jarg1;
22080   {
22081     try {
22082       delete arg1;
22083     } catch (std::out_of_range& e) {
22084       {
22085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22086       };
22087     } catch (std::exception& e) {
22088       {
22089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22090       };
22091     } catch (...) {
22092       {
22093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22094       };
22095     }
22096   }
22097 }
22098
22099
22100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22101   void * jresult ;
22102   Dali::TextureSet *arg1 = 0 ;
22103   Dali::TextureSet *result = 0 ;
22104
22105   arg1 = (Dali::TextureSet *)jarg1;
22106   if (!arg1) {
22107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22108     return 0;
22109   }
22110   {
22111     try {
22112       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22113     } catch (std::out_of_range& e) {
22114       {
22115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22116       };
22117     } catch (std::exception& e) {
22118       {
22119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (...) {
22122       {
22123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22124       };
22125     }
22126   }
22127   jresult = (void *)result;
22128   return jresult;
22129 }
22130
22131
22132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22133   void * jresult ;
22134   Dali::BaseHandle arg1 ;
22135   Dali::BaseHandle *argp1 ;
22136   Dali::TextureSet result;
22137
22138   argp1 = (Dali::BaseHandle *)jarg1;
22139   if (!argp1) {
22140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22141     return 0;
22142   }
22143   arg1 = *argp1;
22144   {
22145     try {
22146       result = Dali::TextureSet::DownCast(arg1);
22147     } catch (std::out_of_range& e) {
22148       {
22149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22150       };
22151     } catch (std::exception& e) {
22152       {
22153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22154       };
22155     } catch (...) {
22156       {
22157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22158       };
22159     }
22160   }
22161   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22162   return jresult;
22163 }
22164
22165
22166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22167   void * jresult ;
22168   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22169   Dali::TextureSet *arg2 = 0 ;
22170   Dali::TextureSet *result = 0 ;
22171
22172   arg1 = (Dali::TextureSet *)jarg1;
22173   arg2 = (Dali::TextureSet *)jarg2;
22174   if (!arg2) {
22175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22176     return 0;
22177   }
22178   {
22179     try {
22180       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22181     } catch (std::out_of_range& e) {
22182       {
22183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22184       };
22185     } catch (std::exception& e) {
22186       {
22187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22188       };
22189     } catch (...) {
22190       {
22191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22192       };
22193     }
22194   }
22195   jresult = (void *)result;
22196   return jresult;
22197 }
22198
22199
22200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22201   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22202   size_t arg2 ;
22203   Dali::Texture arg3 ;
22204   Dali::Texture *argp3 ;
22205
22206   arg1 = (Dali::TextureSet *)jarg1;
22207   arg2 = (size_t)jarg2;
22208   argp3 = (Dali::Texture *)jarg3;
22209   if (!argp3) {
22210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22211     return ;
22212   }
22213   arg3 = *argp3;
22214   {
22215     try {
22216       (arg1)->SetTexture(arg2,arg3);
22217     } catch (std::out_of_range& e) {
22218       {
22219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22220       };
22221     } catch (std::exception& e) {
22222       {
22223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22224       };
22225     } catch (...) {
22226       {
22227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22228       };
22229     }
22230   }
22231 }
22232
22233
22234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22235   void * jresult ;
22236   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22237   size_t arg2 ;
22238   Dali::Texture result;
22239
22240   arg1 = (Dali::TextureSet *)jarg1;
22241   arg2 = (size_t)jarg2;
22242   {
22243     try {
22244       result = ((Dali::TextureSet const *)arg1)->GetTexture(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 = new Dali::Texture((const Dali::Texture &)result);
22260   return jresult;
22261 }
22262
22263
22264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22265   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22266   size_t arg2 ;
22267   Dali::Sampler arg3 ;
22268   Dali::Sampler *argp3 ;
22269
22270   arg1 = (Dali::TextureSet *)jarg1;
22271   arg2 = (size_t)jarg2;
22272   argp3 = (Dali::Sampler *)jarg3;
22273   if (!argp3) {
22274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22275     return ;
22276   }
22277   arg3 = *argp3;
22278   {
22279     try {
22280       (arg1)->SetSampler(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_GetSampler(void * jarg1, unsigned long jarg2) {
22299   void * jresult ;
22300   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22301   size_t arg2 ;
22302   Dali::Sampler result;
22303
22304   arg1 = (Dali::TextureSet *)jarg1;
22305   arg2 = (size_t)jarg2;
22306   {
22307     try {
22308       result = ((Dali::TextureSet const *)arg1)->GetSampler(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::Sampler((const Dali::Sampler &)result);
22324   return jresult;
22325 }
22326
22327
22328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22329   unsigned long jresult ;
22330   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22331   size_t result;
22332
22333   arg1 = (Dali::TextureSet *)jarg1;
22334   {
22335     try {
22336       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22337     } catch (std::out_of_range& e) {
22338       {
22339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22340       };
22341     } catch (std::exception& e) {
22342       {
22343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22344       };
22345     } catch (...) {
22346       {
22347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22348       };
22349     }
22350   }
22351   jresult = (unsigned long)result;
22352   return jresult;
22353 }
22354
22355
22356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22357   void * jresult ;
22358   Dali::Property::Map *arg1 = 0 ;
22359   Dali::PropertyBuffer result;
22360
22361   arg1 = (Dali::Property::Map *)jarg1;
22362   if (!arg1) {
22363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22364     return 0;
22365   }
22366   {
22367     try {
22368       result = Dali::PropertyBuffer::New(*arg1);
22369     } catch (std::out_of_range& e) {
22370       {
22371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22372       };
22373     } catch (std::exception& e) {
22374       {
22375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22376       };
22377     } catch (...) {
22378       {
22379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22380       };
22381     }
22382   }
22383   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22384   return jresult;
22385 }
22386
22387
22388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22389   void * jresult ;
22390   Dali::PropertyBuffer *result = 0 ;
22391
22392   {
22393     try {
22394       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22395     } catch (std::out_of_range& e) {
22396       {
22397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22398       };
22399     } catch (std::exception& e) {
22400       {
22401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22402       };
22403     } catch (...) {
22404       {
22405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22406       };
22407     }
22408   }
22409   jresult = (void *)result;
22410   return jresult;
22411 }
22412
22413
22414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22415   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22416
22417   arg1 = (Dali::PropertyBuffer *)jarg1;
22418   {
22419     try {
22420       delete arg1;
22421     } catch (std::out_of_range& e) {
22422       {
22423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22424       };
22425     } catch (std::exception& e) {
22426       {
22427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22432       };
22433     }
22434   }
22435 }
22436
22437
22438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22439   void * jresult ;
22440   Dali::PropertyBuffer *arg1 = 0 ;
22441   Dali::PropertyBuffer *result = 0 ;
22442
22443   arg1 = (Dali::PropertyBuffer *)jarg1;
22444   if (!arg1) {
22445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22446     return 0;
22447   }
22448   {
22449     try {
22450       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22451     } catch (std::out_of_range& e) {
22452       {
22453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (std::exception& e) {
22456       {
22457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465   jresult = (void *)result;
22466   return jresult;
22467 }
22468
22469
22470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22471   void * jresult ;
22472   Dali::BaseHandle arg1 ;
22473   Dali::BaseHandle *argp1 ;
22474   Dali::PropertyBuffer result;
22475
22476   argp1 = (Dali::BaseHandle *)jarg1;
22477   if (!argp1) {
22478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22479     return 0;
22480   }
22481   arg1 = *argp1;
22482   {
22483     try {
22484       result = Dali::PropertyBuffer::DownCast(arg1);
22485     } catch (std::out_of_range& e) {
22486       {
22487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22488       };
22489     } catch (std::exception& e) {
22490       {
22491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22496       };
22497     }
22498   }
22499   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22500   return jresult;
22501 }
22502
22503
22504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22505   void * jresult ;
22506   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22507   Dali::PropertyBuffer *arg2 = 0 ;
22508   Dali::PropertyBuffer *result = 0 ;
22509
22510   arg1 = (Dali::PropertyBuffer *)jarg1;
22511   arg2 = (Dali::PropertyBuffer *)jarg2;
22512   if (!arg2) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22514     return 0;
22515   }
22516   {
22517     try {
22518       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22519     } catch (std::out_of_range& e) {
22520       {
22521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22522       };
22523     } catch (std::exception& e) {
22524       {
22525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22526       };
22527     } catch (...) {
22528       {
22529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22530       };
22531     }
22532   }
22533   jresult = (void *)result;
22534   return jresult;
22535 }
22536
22537
22538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22539   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22540   void *arg2 = (void *) 0 ;
22541   std::size_t arg3 ;
22542
22543   arg1 = (Dali::PropertyBuffer *)jarg1;
22544   arg2 = jarg2;
22545   arg3 = (std::size_t)jarg3;
22546   {
22547     try {
22548       (arg1)->SetData((void const *)arg2,arg3);
22549     } catch (std::out_of_range& e) {
22550       {
22551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22552       };
22553     } catch (std::exception& e) {
22554       {
22555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22556       };
22557     } catch (...) {
22558       {
22559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22560       };
22561     }
22562   }
22563 }
22564
22565
22566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22567   unsigned long jresult ;
22568   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22569   std::size_t result;
22570
22571   arg1 = (Dali::PropertyBuffer *)jarg1;
22572   {
22573     try {
22574       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22575     } catch (std::out_of_range& e) {
22576       {
22577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22578       };
22579     } catch (std::exception& e) {
22580       {
22581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22582       };
22583     } catch (...) {
22584       {
22585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22586       };
22587     }
22588   }
22589   jresult = (unsigned long)result;
22590   return jresult;
22591 }
22592
22593
22594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22595   void * jresult ;
22596   Dali::Geometry result;
22597
22598   {
22599     try {
22600       result = Dali::Geometry::New();
22601     } catch (std::out_of_range& e) {
22602       {
22603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22604       };
22605     } catch (std::exception& e) {
22606       {
22607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22608       };
22609     } catch (...) {
22610       {
22611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22612       };
22613     }
22614   }
22615   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22616   return jresult;
22617 }
22618
22619
22620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22621   void * jresult ;
22622   Dali::Geometry *result = 0 ;
22623
22624   {
22625     try {
22626       result = (Dali::Geometry *)new Dali::Geometry();
22627     } catch (std::out_of_range& e) {
22628       {
22629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22630       };
22631     } catch (std::exception& e) {
22632       {
22633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22634       };
22635     } catch (...) {
22636       {
22637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22638       };
22639     }
22640   }
22641   jresult = (void *)result;
22642   return jresult;
22643 }
22644
22645
22646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22647   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22648
22649   arg1 = (Dali::Geometry *)jarg1;
22650   {
22651     try {
22652       delete arg1;
22653     } catch (std::out_of_range& e) {
22654       {
22655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22656       };
22657     } catch (std::exception& e) {
22658       {
22659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22660       };
22661     } catch (...) {
22662       {
22663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22664       };
22665     }
22666   }
22667 }
22668
22669
22670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22671   void * jresult ;
22672   Dali::Geometry *arg1 = 0 ;
22673   Dali::Geometry *result = 0 ;
22674
22675   arg1 = (Dali::Geometry *)jarg1;
22676   if (!arg1) {
22677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22678     return 0;
22679   }
22680   {
22681     try {
22682       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22683     } catch (std::out_of_range& e) {
22684       {
22685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22686       };
22687     } catch (std::exception& e) {
22688       {
22689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22690       };
22691     } catch (...) {
22692       {
22693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22694       };
22695     }
22696   }
22697   jresult = (void *)result;
22698   return jresult;
22699 }
22700
22701
22702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22703   void * jresult ;
22704   Dali::BaseHandle arg1 ;
22705   Dali::BaseHandle *argp1 ;
22706   Dali::Geometry result;
22707
22708   argp1 = (Dali::BaseHandle *)jarg1;
22709   if (!argp1) {
22710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22711     return 0;
22712   }
22713   arg1 = *argp1;
22714   {
22715     try {
22716       result = Dali::Geometry::DownCast(arg1);
22717     } catch (std::out_of_range& e) {
22718       {
22719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22720       };
22721     } catch (std::exception& e) {
22722       {
22723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22724       };
22725     } catch (...) {
22726       {
22727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22728       };
22729     }
22730   }
22731   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22732   return jresult;
22733 }
22734
22735
22736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22737   void * jresult ;
22738   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22739   Dali::Geometry *arg2 = 0 ;
22740   Dali::Geometry *result = 0 ;
22741
22742   arg1 = (Dali::Geometry *)jarg1;
22743   arg2 = (Dali::Geometry *)jarg2;
22744   if (!arg2) {
22745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22746     return 0;
22747   }
22748   {
22749     try {
22750       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22751     } catch (std::out_of_range& e) {
22752       {
22753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (std::exception& e) {
22756       {
22757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22758       };
22759     } catch (...) {
22760       {
22761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22762       };
22763     }
22764   }
22765   jresult = (void *)result;
22766   return jresult;
22767 }
22768
22769
22770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22771   unsigned long jresult ;
22772   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22773   Dali::PropertyBuffer *arg2 = 0 ;
22774   std::size_t result;
22775
22776   arg1 = (Dali::Geometry *)jarg1;
22777   arg2 = (Dali::PropertyBuffer *)jarg2;
22778   if (!arg2) {
22779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22780     return 0;
22781   }
22782   {
22783     try {
22784       result = (arg1)->AddVertexBuffer(*arg2);
22785     } catch (std::out_of_range& e) {
22786       {
22787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22788       };
22789     } catch (std::exception& e) {
22790       {
22791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22796       };
22797     }
22798   }
22799   jresult = (unsigned long)result;
22800   return jresult;
22801 }
22802
22803
22804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22805   unsigned long jresult ;
22806   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22807   std::size_t result;
22808
22809   arg1 = (Dali::Geometry *)jarg1;
22810   {
22811     try {
22812       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22813     } catch (std::out_of_range& e) {
22814       {
22815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22816       };
22817     } catch (std::exception& e) {
22818       {
22819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22820       };
22821     } catch (...) {
22822       {
22823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22824       };
22825     }
22826   }
22827   jresult = (unsigned long)result;
22828   return jresult;
22829 }
22830
22831
22832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22833   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22834   std::size_t arg2 ;
22835
22836   arg1 = (Dali::Geometry *)jarg1;
22837   arg2 = (std::size_t)jarg2;
22838   {
22839     try {
22840       (arg1)->RemoveVertexBuffer(arg2);
22841     } catch (std::out_of_range& e) {
22842       {
22843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22844       };
22845     } catch (std::exception& e) {
22846       {
22847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22848       };
22849     } catch (...) {
22850       {
22851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22852       };
22853     }
22854   }
22855 }
22856
22857
22858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22859   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22860   unsigned short *arg2 = (unsigned short *) 0 ;
22861   size_t arg3 ;
22862
22863   arg1 = (Dali::Geometry *)jarg1;
22864   arg2 = jarg2;
22865   arg3 = (size_t)jarg3;
22866   {
22867     try {
22868       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22869     } catch (std::out_of_range& e) {
22870       {
22871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22872       };
22873     } catch (std::exception& e) {
22874       {
22875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22876       };
22877     } catch (...) {
22878       {
22879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22880       };
22881     }
22882   }
22883
22884
22885 }
22886
22887
22888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22889   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22890   Dali::Geometry::Type arg2 ;
22891
22892   arg1 = (Dali::Geometry *)jarg1;
22893   arg2 = (Dali::Geometry::Type)jarg2;
22894   {
22895     try {
22896       (arg1)->SetType(arg2);
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22904       };
22905     } catch (...) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22908       };
22909     }
22910   }
22911 }
22912
22913
22914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22915   int jresult ;
22916   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22917   Dali::Geometry::Type result;
22918
22919   arg1 = (Dali::Geometry *)jarg1;
22920   {
22921     try {
22922       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22923     } catch (std::out_of_range& e) {
22924       {
22925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22926       };
22927     } catch (std::exception& e) {
22928       {
22929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22930       };
22931     } catch (...) {
22932       {
22933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22934       };
22935     }
22936   }
22937   jresult = (int)result;
22938   return jresult;
22939 }
22940
22941
22942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22943   void * jresult ;
22944   Dali::Shader::Hint *result = 0 ;
22945
22946   {
22947     try {
22948       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22949     } catch (std::out_of_range& e) {
22950       {
22951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22952       };
22953     } catch (std::exception& e) {
22954       {
22955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22956       };
22957     } catch (...) {
22958       {
22959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22960       };
22961     }
22962   }
22963   jresult = (void *)result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22969   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22970
22971   arg1 = (Dali::Shader::Hint *)jarg1;
22972   {
22973     try {
22974       delete arg1;
22975     } catch (std::out_of_range& e) {
22976       {
22977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22978       };
22979     } catch (std::exception& e) {
22980       {
22981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22982       };
22983     } catch (...) {
22984       {
22985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22986       };
22987     }
22988   }
22989 }
22990
22991
22992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22993   int jresult ;
22994   int result;
22995
22996   result = (int)Dali::Shader::Property::PROGRAM;
22997   jresult = (int)result;
22998   return jresult;
22999 }
23000
23001
23002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23003   void * jresult ;
23004   Dali::Shader::Property *result = 0 ;
23005
23006   {
23007     try {
23008       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23009     } catch (std::out_of_range& e) {
23010       {
23011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23012       };
23013     } catch (std::exception& e) {
23014       {
23015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23016       };
23017     } catch (...) {
23018       {
23019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23020       };
23021     }
23022   }
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23029   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23030
23031   arg1 = (Dali::Shader::Property *)jarg1;
23032   {
23033     try {
23034       delete arg1;
23035     } catch (std::out_of_range& e) {
23036       {
23037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23038       };
23039     } catch (std::exception& e) {
23040       {
23041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23042       };
23043     } catch (...) {
23044       {
23045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23046       };
23047     }
23048   }
23049 }
23050
23051
23052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23053   void * jresult ;
23054   std::string *arg1 = 0 ;
23055   std::string *arg2 = 0 ;
23056   Dali::Shader::Hint::Value arg3 ;
23057   Dali::Shader result;
23058
23059   if (!jarg1) {
23060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23061     return 0;
23062   }
23063   std::string arg1_str(jarg1);
23064   arg1 = &arg1_str;
23065   if (!jarg2) {
23066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23067     return 0;
23068   }
23069   std::string arg2_str(jarg2);
23070   arg2 = &arg2_str;
23071   arg3 = (Dali::Shader::Hint::Value)jarg3;
23072   {
23073     try {
23074       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23075     } catch (std::out_of_range& e) {
23076       {
23077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23078       };
23079     } catch (std::exception& e) {
23080       {
23081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23082       };
23083     } catch (...) {
23084       {
23085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23086       };
23087     }
23088   }
23089   jresult = new Dali::Shader((const Dali::Shader &)result);
23090
23091   //argout typemap for const std::string&
23092
23093
23094   //argout typemap for const std::string&
23095
23096   return jresult;
23097 }
23098
23099
23100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23101   void * jresult ;
23102   std::string *arg1 = 0 ;
23103   std::string *arg2 = 0 ;
23104   Dali::Shader result;
23105
23106   if (!jarg1) {
23107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23108     return 0;
23109   }
23110   std::string arg1_str(jarg1);
23111   arg1 = &arg1_str;
23112   if (!jarg2) {
23113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23114     return 0;
23115   }
23116   std::string arg2_str(jarg2);
23117   arg2 = &arg2_str;
23118   {
23119     try {
23120       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23121     } catch (std::out_of_range& e) {
23122       {
23123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23124       };
23125     } catch (std::exception& e) {
23126       {
23127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23128       };
23129     } catch (...) {
23130       {
23131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23132       };
23133     }
23134   }
23135   jresult = new Dali::Shader((const Dali::Shader &)result);
23136
23137   //argout typemap for const std::string&
23138
23139
23140   //argout typemap for const std::string&
23141
23142   return jresult;
23143 }
23144
23145
23146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23147   void * jresult ;
23148   Dali::Shader *result = 0 ;
23149
23150   {
23151     try {
23152       result = (Dali::Shader *)new Dali::Shader();
23153     } catch (std::out_of_range& e) {
23154       {
23155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23156       };
23157     } catch (std::exception& e) {
23158       {
23159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23160       };
23161     } catch (...) {
23162       {
23163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23164       };
23165     }
23166   }
23167   jresult = (void *)result;
23168   return jresult;
23169 }
23170
23171
23172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23173   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23174
23175   arg1 = (Dali::Shader *)jarg1;
23176   {
23177     try {
23178       delete arg1;
23179     } catch (std::out_of_range& e) {
23180       {
23181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23182       };
23183     } catch (std::exception& e) {
23184       {
23185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23186       };
23187     } catch (...) {
23188       {
23189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23190       };
23191     }
23192   }
23193 }
23194
23195
23196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23197   void * jresult ;
23198   Dali::Shader *arg1 = 0 ;
23199   Dali::Shader *result = 0 ;
23200
23201   arg1 = (Dali::Shader *)jarg1;
23202   if (!arg1) {
23203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23204     return 0;
23205   }
23206   {
23207     try {
23208       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23209     } catch (std::out_of_range& e) {
23210       {
23211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23212       };
23213     } catch (std::exception& e) {
23214       {
23215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23216       };
23217     } catch (...) {
23218       {
23219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23220       };
23221     }
23222   }
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23229   void * jresult ;
23230   Dali::BaseHandle arg1 ;
23231   Dali::BaseHandle *argp1 ;
23232   Dali::Shader result;
23233
23234   argp1 = (Dali::BaseHandle *)jarg1;
23235   if (!argp1) {
23236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23237     return 0;
23238   }
23239   arg1 = *argp1;
23240   {
23241     try {
23242       result = Dali::Shader::DownCast(arg1);
23243     } catch (std::out_of_range& e) {
23244       {
23245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23246       };
23247     } catch (std::exception& e) {
23248       {
23249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23250       };
23251     } catch (...) {
23252       {
23253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23254       };
23255     }
23256   }
23257   jresult = new Dali::Shader((const Dali::Shader &)result);
23258   return jresult;
23259 }
23260
23261
23262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23263   void * jresult ;
23264   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23265   Dali::Shader *arg2 = 0 ;
23266   Dali::Shader *result = 0 ;
23267
23268   arg1 = (Dali::Shader *)jarg1;
23269   arg2 = (Dali::Shader *)jarg2;
23270   if (!arg2) {
23271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23272     return 0;
23273   }
23274   {
23275     try {
23276       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23277     } catch (std::out_of_range& e) {
23278       {
23279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23280       };
23281     } catch (std::exception& e) {
23282       {
23283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23284       };
23285     } catch (...) {
23286       {
23287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23288       };
23289     }
23290   }
23291   jresult = (void *)result;
23292   return jresult;
23293 }
23294
23295
23296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23297   int jresult ;
23298   int result;
23299
23300   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23301   jresult = (int)result;
23302   return jresult;
23303 }
23304
23305
23306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23307   int jresult ;
23308   int result;
23309
23310   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23311   jresult = (int)result;
23312   return jresult;
23313 }
23314
23315
23316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23317   int jresult ;
23318   int result;
23319
23320   result = (int)Dali::Renderer::Property::BLEND_MODE;
23321   jresult = (int)result;
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23327   int jresult ;
23328   int result;
23329
23330   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23331   jresult = (int)result;
23332   return jresult;
23333 }
23334
23335
23336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23337   int jresult ;
23338   int result;
23339
23340   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23341   jresult = (int)result;
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23347   int jresult ;
23348   int result;
23349
23350   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23351   jresult = (int)result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23357   int jresult ;
23358   int result;
23359
23360   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23361   jresult = (int)result;
23362   return jresult;
23363 }
23364
23365
23366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23367   int jresult ;
23368   int result;
23369
23370   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23371   jresult = (int)result;
23372   return jresult;
23373 }
23374
23375
23376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23377   int jresult ;
23378   int result;
23379
23380   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23381   jresult = (int)result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23387   int jresult ;
23388   int result;
23389
23390   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23391   jresult = (int)result;
23392   return jresult;
23393 }
23394
23395
23396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23397   int jresult ;
23398   int result;
23399
23400   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23401   jresult = (int)result;
23402   return jresult;
23403 }
23404
23405
23406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23407   int jresult ;
23408   int result;
23409
23410   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23411   jresult = (int)result;
23412   return jresult;
23413 }
23414
23415
23416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23417   int jresult ;
23418   int result;
23419
23420   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23421   jresult = (int)result;
23422   return jresult;
23423 }
23424
23425
23426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23427   int jresult ;
23428   int result;
23429
23430   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23431   jresult = (int)result;
23432   return jresult;
23433 }
23434
23435
23436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23437   int jresult ;
23438   int result;
23439
23440   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23441   jresult = (int)result;
23442   return jresult;
23443 }
23444
23445
23446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23447   int jresult ;
23448   int result;
23449
23450   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23451   jresult = (int)result;
23452   return jresult;
23453 }
23454
23455
23456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23457   int jresult ;
23458   int result;
23459
23460   result = (int)Dali::Renderer::Property::RENDER_MODE;
23461   jresult = (int)result;
23462   return jresult;
23463 }
23464
23465
23466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23467   int jresult ;
23468   int result;
23469
23470   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23471   jresult = (int)result;
23472   return jresult;
23473 }
23474
23475
23476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23477   int jresult ;
23478   int result;
23479
23480   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23481   jresult = (int)result;
23482   return jresult;
23483 }
23484
23485
23486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23487   int jresult ;
23488   int result;
23489
23490   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23491   jresult = (int)result;
23492   return jresult;
23493 }
23494
23495
23496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23497   int jresult ;
23498   int result;
23499
23500   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23501   jresult = (int)result;
23502   return jresult;
23503 }
23504
23505
23506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23507   int jresult ;
23508   int result;
23509
23510   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23511   jresult = (int)result;
23512   return jresult;
23513 }
23514
23515
23516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23517   int jresult ;
23518   int result;
23519
23520   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23521   jresult = (int)result;
23522   return jresult;
23523 }
23524
23525
23526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23527   int jresult ;
23528   int result;
23529
23530   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23531   jresult = (int)result;
23532   return jresult;
23533 }
23534
23535
23536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23537   void * jresult ;
23538   Dali::Renderer::Property *result = 0 ;
23539
23540   {
23541     try {
23542       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23543     } catch (std::out_of_range& e) {
23544       {
23545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23546       };
23547     } catch (std::exception& e) {
23548       {
23549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23550       };
23551     } catch (...) {
23552       {
23553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23554       };
23555     }
23556   }
23557   jresult = (void *)result;
23558   return jresult;
23559 }
23560
23561
23562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23563   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23564
23565   arg1 = (Dali::Renderer::Property *)jarg1;
23566   {
23567     try {
23568       delete arg1;
23569     } catch (std::out_of_range& e) {
23570       {
23571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23572       };
23573     } catch (std::exception& e) {
23574       {
23575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23576       };
23577     } catch (...) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23580       };
23581     }
23582   }
23583 }
23584
23585
23586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23587   void * jresult ;
23588   Dali::Geometry *arg1 = 0 ;
23589   Dali::Shader *arg2 = 0 ;
23590   Dali::Renderer result;
23591
23592   arg1 = (Dali::Geometry *)jarg1;
23593   if (!arg1) {
23594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23595     return 0;
23596   }
23597   arg2 = (Dali::Shader *)jarg2;
23598   if (!arg2) {
23599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23600     return 0;
23601   }
23602   {
23603     try {
23604       result = Dali::Renderer::New(*arg1,*arg2);
23605     } catch (std::out_of_range& e) {
23606       {
23607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23608       };
23609     } catch (std::exception& e) {
23610       {
23611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23612       };
23613     } catch (...) {
23614       {
23615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23616       };
23617     }
23618   }
23619   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23620   return jresult;
23621 }
23622
23623
23624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23625   void * jresult ;
23626   Dali::Renderer *result = 0 ;
23627
23628   {
23629     try {
23630       result = (Dali::Renderer *)new Dali::Renderer();
23631     } catch (std::out_of_range& e) {
23632       {
23633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23634       };
23635     } catch (std::exception& e) {
23636       {
23637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23638       };
23639     } catch (...) {
23640       {
23641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23642       };
23643     }
23644   }
23645   jresult = (void *)result;
23646   return jresult;
23647 }
23648
23649
23650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23651   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23652
23653   arg1 = (Dali::Renderer *)jarg1;
23654   {
23655     try {
23656       delete arg1;
23657     } catch (std::out_of_range& e) {
23658       {
23659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23660       };
23661     } catch (std::exception& e) {
23662       {
23663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23664       };
23665     } catch (...) {
23666       {
23667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23668       };
23669     }
23670   }
23671 }
23672
23673
23674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23675   void * jresult ;
23676   Dali::Renderer *arg1 = 0 ;
23677   Dali::Renderer *result = 0 ;
23678
23679   arg1 = (Dali::Renderer *)jarg1;
23680   if (!arg1) {
23681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23682     return 0;
23683   }
23684   {
23685     try {
23686       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23687     } catch (std::out_of_range& e) {
23688       {
23689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23690       };
23691     } catch (std::exception& e) {
23692       {
23693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23694       };
23695     } catch (...) {
23696       {
23697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23698       };
23699     }
23700   }
23701   jresult = (void *)result;
23702   return jresult;
23703 }
23704
23705
23706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23707   void * jresult ;
23708   Dali::BaseHandle arg1 ;
23709   Dali::BaseHandle *argp1 ;
23710   Dali::Renderer result;
23711
23712   argp1 = (Dali::BaseHandle *)jarg1;
23713   if (!argp1) {
23714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23715     return 0;
23716   }
23717   arg1 = *argp1;
23718   {
23719     try {
23720       result = Dali::Renderer::DownCast(arg1);
23721     } catch (std::out_of_range& e) {
23722       {
23723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23724       };
23725     } catch (std::exception& e) {
23726       {
23727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23728       };
23729     } catch (...) {
23730       {
23731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23732       };
23733     }
23734   }
23735   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23736   return jresult;
23737 }
23738
23739
23740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23741   void * jresult ;
23742   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23743   Dali::Renderer *arg2 = 0 ;
23744   Dali::Renderer *result = 0 ;
23745
23746   arg1 = (Dali::Renderer *)jarg1;
23747   arg2 = (Dali::Renderer *)jarg2;
23748   if (!arg2) {
23749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23750     return 0;
23751   }
23752   {
23753     try {
23754       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23755     } catch (std::out_of_range& e) {
23756       {
23757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23758       };
23759     } catch (std::exception& e) {
23760       {
23761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23762       };
23763     } catch (...) {
23764       {
23765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23766       };
23767     }
23768   }
23769   jresult = (void *)result;
23770   return jresult;
23771 }
23772
23773
23774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23775   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23776   Dali::Geometry *arg2 = 0 ;
23777
23778   arg1 = (Dali::Renderer *)jarg1;
23779   arg2 = (Dali::Geometry *)jarg2;
23780   if (!arg2) {
23781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23782     return ;
23783   }
23784   {
23785     try {
23786       (arg1)->SetGeometry(*arg2);
23787     } catch (std::out_of_range& e) {
23788       {
23789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23790       };
23791     } catch (std::exception& e) {
23792       {
23793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23794       };
23795     } catch (...) {
23796       {
23797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23798       };
23799     }
23800   }
23801 }
23802
23803
23804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23805   void * jresult ;
23806   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23807   Dali::Geometry result;
23808
23809   arg1 = (Dali::Renderer *)jarg1;
23810   {
23811     try {
23812       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23813     } catch (std::out_of_range& e) {
23814       {
23815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23816       };
23817     } catch (std::exception& e) {
23818       {
23819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23820       };
23821     } catch (...) {
23822       {
23823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23824       };
23825     }
23826   }
23827   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23828   return jresult;
23829 }
23830
23831
23832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23833   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23834   int arg2 ;
23835   int arg3 ;
23836
23837   arg1 = (Dali::Renderer *)jarg1;
23838   arg2 = (int)jarg2;
23839   arg3 = (int)jarg3;
23840   {
23841     try {
23842       (arg1)->SetIndexRange(arg2,arg3);
23843     } catch (std::out_of_range& e) {
23844       {
23845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23846       };
23847     } catch (std::exception& e) {
23848       {
23849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23850       };
23851     } catch (...) {
23852       {
23853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23854       };
23855     }
23856   }
23857 }
23858
23859
23860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23861   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23862   Dali::TextureSet *arg2 = 0 ;
23863
23864   arg1 = (Dali::Renderer *)jarg1;
23865   arg2 = (Dali::TextureSet *)jarg2;
23866   if (!arg2) {
23867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23868     return ;
23869   }
23870   {
23871     try {
23872       (arg1)->SetTextures(*arg2);
23873     } catch (std::out_of_range& e) {
23874       {
23875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23876       };
23877     } catch (std::exception& e) {
23878       {
23879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23880       };
23881     } catch (...) {
23882       {
23883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23884       };
23885     }
23886   }
23887 }
23888
23889
23890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23891   void * jresult ;
23892   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23893   Dali::TextureSet result;
23894
23895   arg1 = (Dali::Renderer *)jarg1;
23896   {
23897     try {
23898       result = ((Dali::Renderer const *)arg1)->GetTextures();
23899     } catch (std::out_of_range& e) {
23900       {
23901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (std::exception& e) {
23904       {
23905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23906       };
23907     } catch (...) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23910       };
23911     }
23912   }
23913   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23914   return jresult;
23915 }
23916
23917
23918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23919   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23920   Dali::Shader *arg2 = 0 ;
23921
23922   arg1 = (Dali::Renderer *)jarg1;
23923   arg2 = (Dali::Shader *)jarg2;
23924   if (!arg2) {
23925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23926     return ;
23927   }
23928   {
23929     try {
23930       (arg1)->SetShader(*arg2);
23931     } catch (std::out_of_range& e) {
23932       {
23933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23934       };
23935     } catch (std::exception& e) {
23936       {
23937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23938       };
23939     } catch (...) {
23940       {
23941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23942       };
23943     }
23944   }
23945 }
23946
23947
23948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23949   void * jresult ;
23950   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23951   Dali::Shader result;
23952
23953   arg1 = (Dali::Renderer *)jarg1;
23954   {
23955     try {
23956       result = ((Dali::Renderer const *)arg1)->GetShader();
23957     } catch (std::out_of_range& e) {
23958       {
23959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23960       };
23961     } catch (std::exception& e) {
23962       {
23963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23964       };
23965     } catch (...) {
23966       {
23967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23968       };
23969     }
23970   }
23971   jresult = new Dali::Shader((const Dali::Shader &)result);
23972   return jresult;
23973 }
23974
23975
23976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23977   void * jresult ;
23978   Dali::FrameBuffer::Attachment *result = 0 ;
23979
23980   {
23981     try {
23982       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23983     } catch (std::out_of_range& e) {
23984       {
23985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (std::exception& e) {
23988       {
23989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997   jresult = (void *)result;
23998   return jresult;
23999 }
24000
24001
24002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24003   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24004
24005   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24006   {
24007     try {
24008       delete arg1;
24009     } catch (std::out_of_range& e) {
24010       {
24011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24012       };
24013     } catch (std::exception& e) {
24014       {
24015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24016       };
24017     } catch (...) {
24018       {
24019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24020       };
24021     }
24022   }
24023 }
24024
24025
24026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24027   void * jresult ;
24028   unsigned int arg1 ;
24029   unsigned int arg2 ;
24030   unsigned int arg3 ;
24031   Dali::FrameBuffer result;
24032
24033   arg1 = (unsigned int)jarg1;
24034   arg2 = (unsigned int)jarg2;
24035   arg3 = (unsigned int)jarg3;
24036   {
24037     try {
24038       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24039     } catch (std::out_of_range& e) {
24040       {
24041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24042       };
24043     } catch (std::exception& e) {
24044       {
24045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24046       };
24047     } catch (...) {
24048       {
24049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24050       };
24051     }
24052   }
24053   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24054   return jresult;
24055 }
24056
24057
24058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24059   void * jresult ;
24060   Dali::FrameBuffer *result = 0 ;
24061
24062   {
24063     try {
24064       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24065     } catch (std::out_of_range& e) {
24066       {
24067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24068       };
24069     } catch (std::exception& e) {
24070       {
24071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24072       };
24073     } catch (...) {
24074       {
24075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24076       };
24077     }
24078   }
24079   jresult = (void *)result;
24080   return jresult;
24081 }
24082
24083
24084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24085   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24086
24087   arg1 = (Dali::FrameBuffer *)jarg1;
24088   {
24089     try {
24090       delete arg1;
24091     } catch (std::out_of_range& e) {
24092       {
24093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24094       };
24095     } catch (std::exception& e) {
24096       {
24097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24098       };
24099     } catch (...) {
24100       {
24101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24102       };
24103     }
24104   }
24105 }
24106
24107
24108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24109   void * jresult ;
24110   Dali::FrameBuffer *arg1 = 0 ;
24111   Dali::FrameBuffer *result = 0 ;
24112
24113   arg1 = (Dali::FrameBuffer *)jarg1;
24114   if (!arg1) {
24115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24116     return 0;
24117   }
24118   {
24119     try {
24120       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24121     } catch (std::out_of_range& e) {
24122       {
24123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (std::exception& e) {
24126       {
24127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24132       };
24133     }
24134   }
24135   jresult = (void *)result;
24136   return jresult;
24137 }
24138
24139
24140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24141   void * jresult ;
24142   Dali::BaseHandle arg1 ;
24143   Dali::BaseHandle *argp1 ;
24144   Dali::FrameBuffer result;
24145
24146   argp1 = (Dali::BaseHandle *)jarg1;
24147   if (!argp1) {
24148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24149     return 0;
24150   }
24151   arg1 = *argp1;
24152   {
24153     try {
24154       result = Dali::FrameBuffer::DownCast(arg1);
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24162       };
24163     } catch (...) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24166       };
24167     }
24168   }
24169   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24170   return jresult;
24171 }
24172
24173
24174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24175   void * jresult ;
24176   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24177   Dali::FrameBuffer *arg2 = 0 ;
24178   Dali::FrameBuffer *result = 0 ;
24179
24180   arg1 = (Dali::FrameBuffer *)jarg1;
24181   arg2 = (Dali::FrameBuffer *)jarg2;
24182   if (!arg2) {
24183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24184     return 0;
24185   }
24186   {
24187     try {
24188       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24189     } catch (std::out_of_range& e) {
24190       {
24191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (std::exception& e) {
24194       {
24195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24196       };
24197     } catch (...) {
24198       {
24199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24200       };
24201     }
24202   }
24203   jresult = (void *)result;
24204   return jresult;
24205 }
24206
24207
24208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24209   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24210   Dali::Texture *arg2 = 0 ;
24211
24212   arg1 = (Dali::FrameBuffer *)jarg1;
24213   arg2 = (Dali::Texture *)jarg2;
24214   if (!arg2) {
24215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24216     return ;
24217   }
24218   {
24219     try {
24220       (arg1)->AttachColorTexture(*arg2);
24221     } catch (std::out_of_range& e) {
24222       {
24223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24224       };
24225     } catch (std::exception& e) {
24226       {
24227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24228       };
24229     } catch (...) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24232       };
24233     }
24234   }
24235 }
24236
24237
24238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24239   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24240   Dali::Texture *arg2 = 0 ;
24241   unsigned int arg3 ;
24242   unsigned int arg4 ;
24243
24244   arg1 = (Dali::FrameBuffer *)jarg1;
24245   arg2 = (Dali::Texture *)jarg2;
24246   if (!arg2) {
24247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24248     return ;
24249   }
24250   arg3 = (unsigned int)jarg3;
24251   arg4 = (unsigned int)jarg4;
24252   {
24253     try {
24254       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24255     } catch (std::out_of_range& e) {
24256       {
24257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24258       };
24259     } catch (std::exception& e) {
24260       {
24261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24262       };
24263     } catch (...) {
24264       {
24265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24266       };
24267     }
24268   }
24269 }
24270
24271
24272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24273   void * jresult ;
24274   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24275   Dali::Texture result;
24276
24277   arg1 = (Dali::FrameBuffer *)jarg1;
24278   {
24279     try {
24280       result = (arg1)->GetColorTexture();
24281     } catch (std::out_of_range& e) {
24282       {
24283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24284       };
24285     } catch (std::exception& e) {
24286       {
24287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24288       };
24289     } catch (...) {
24290       {
24291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24292       };
24293     }
24294   }
24295   jresult = new Dali::Texture((const Dali::Texture &)result);
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24301   void * jresult ;
24302   Dali::RenderTaskList *result = 0 ;
24303
24304   {
24305     try {
24306       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24307     } catch (std::out_of_range& e) {
24308       {
24309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24310       };
24311     } catch (std::exception& e) {
24312       {
24313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24314       };
24315     } catch (...) {
24316       {
24317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24318       };
24319     }
24320   }
24321   jresult = (void *)result;
24322   return jresult;
24323 }
24324
24325
24326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24327   void * jresult ;
24328   Dali::BaseHandle arg1 ;
24329   Dali::BaseHandle *argp1 ;
24330   Dali::RenderTaskList result;
24331
24332   argp1 = (Dali::BaseHandle *)jarg1;
24333   if (!argp1) {
24334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24335     return 0;
24336   }
24337   arg1 = *argp1;
24338   {
24339     try {
24340       result = Dali::RenderTaskList::DownCast(arg1);
24341     } catch (std::out_of_range& e) {
24342       {
24343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24344       };
24345     } catch (std::exception& e) {
24346       {
24347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24348       };
24349     } catch (...) {
24350       {
24351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24352       };
24353     }
24354   }
24355   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24356   return jresult;
24357 }
24358
24359
24360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24361   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24362
24363   arg1 = (Dali::RenderTaskList *)jarg1;
24364   {
24365     try {
24366       delete arg1;
24367     } catch (std::out_of_range& e) {
24368       {
24369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24370       };
24371     } catch (std::exception& e) {
24372       {
24373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24374       };
24375     } catch (...) {
24376       {
24377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24378       };
24379     }
24380   }
24381 }
24382
24383
24384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24385   void * jresult ;
24386   Dali::RenderTaskList *arg1 = 0 ;
24387   Dali::RenderTaskList *result = 0 ;
24388
24389   arg1 = (Dali::RenderTaskList *)jarg1;
24390   if (!arg1) {
24391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24392     return 0;
24393   }
24394   {
24395     try {
24396       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24397     } catch (std::out_of_range& e) {
24398       {
24399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24400       };
24401     } catch (std::exception& e) {
24402       {
24403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24404       };
24405     } catch (...) {
24406       {
24407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24408       };
24409     }
24410   }
24411   jresult = (void *)result;
24412   return jresult;
24413 }
24414
24415
24416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24417   void * jresult ;
24418   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24419   Dali::RenderTaskList *arg2 = 0 ;
24420   Dali::RenderTaskList *result = 0 ;
24421
24422   arg1 = (Dali::RenderTaskList *)jarg1;
24423   arg2 = (Dali::RenderTaskList *)jarg2;
24424   if (!arg2) {
24425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24426     return 0;
24427   }
24428   {
24429     try {
24430       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24431     } catch (std::out_of_range& e) {
24432       {
24433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24434       };
24435     } catch (std::exception& e) {
24436       {
24437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24438       };
24439     } catch (...) {
24440       {
24441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24442       };
24443     }
24444   }
24445   jresult = (void *)result;
24446   return jresult;
24447 }
24448
24449
24450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24451   void * jresult ;
24452   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24453   Dali::RenderTask result;
24454
24455   arg1 = (Dali::RenderTaskList *)jarg1;
24456   {
24457     try {
24458       result = (arg1)->CreateTask();
24459     } catch (std::out_of_range& e) {
24460       {
24461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24462       };
24463     } catch (std::exception& e) {
24464       {
24465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24466       };
24467     } catch (...) {
24468       {
24469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24470       };
24471     }
24472   }
24473   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24474   return jresult;
24475 }
24476
24477
24478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24479   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24480   Dali::RenderTask arg2 ;
24481   Dali::RenderTask *argp2 ;
24482
24483   arg1 = (Dali::RenderTaskList *)jarg1;
24484   argp2 = (Dali::RenderTask *)jarg2;
24485   if (!argp2) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24487     return ;
24488   }
24489   arg2 = *argp2;
24490   {
24491     try {
24492       (arg1)->RemoveTask(arg2);
24493     } catch (std::out_of_range& e) {
24494       {
24495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24496       };
24497     } catch (std::exception& e) {
24498       {
24499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24500       };
24501     } catch (...) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24504       };
24505     }
24506   }
24507 }
24508
24509
24510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24511   unsigned int jresult ;
24512   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24513   unsigned int result;
24514
24515   arg1 = (Dali::RenderTaskList *)jarg1;
24516   {
24517     try {
24518       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24519     } catch (std::out_of_range& e) {
24520       {
24521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24522       };
24523     } catch (std::exception& e) {
24524       {
24525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24526       };
24527     } catch (...) {
24528       {
24529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24530       };
24531     }
24532   }
24533   jresult = result;
24534   return jresult;
24535 }
24536
24537
24538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24539   void * jresult ;
24540   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24541   unsigned int arg2 ;
24542   Dali::RenderTask result;
24543
24544   arg1 = (Dali::RenderTaskList *)jarg1;
24545   arg2 = (unsigned int)jarg2;
24546   {
24547     try {
24548       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24549     } catch (std::out_of_range& e) {
24550       {
24551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24552       };
24553     } catch (std::exception& e) {
24554       {
24555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24556       };
24557     } catch (...) {
24558       {
24559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24560       };
24561     }
24562   }
24563   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24564   return jresult;
24565 }
24566
24567
24568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24569   int jresult ;
24570   int result;
24571
24572   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24573   jresult = (int)result;
24574   return jresult;
24575 }
24576
24577
24578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24579   int jresult ;
24580   int result;
24581
24582   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24583   jresult = (int)result;
24584   return jresult;
24585 }
24586
24587
24588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24589   int jresult ;
24590   int result;
24591
24592   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24593   jresult = (int)result;
24594   return jresult;
24595 }
24596
24597
24598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24599   int jresult ;
24600   int result;
24601
24602   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24603   jresult = (int)result;
24604   return jresult;
24605 }
24606
24607
24608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24609   void * jresult ;
24610   Dali::RenderTask::Property *result = 0 ;
24611
24612   {
24613     try {
24614       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24615     } catch (std::out_of_range& e) {
24616       {
24617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24618       };
24619     } catch (std::exception& e) {
24620       {
24621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24622       };
24623     } catch (...) {
24624       {
24625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24626       };
24627     }
24628   }
24629   jresult = (void *)result;
24630   return jresult;
24631 }
24632
24633
24634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24635   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24636
24637   arg1 = (Dali::RenderTask::Property *)jarg1;
24638   {
24639     try {
24640       delete arg1;
24641     } catch (std::out_of_range& e) {
24642       {
24643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24644       };
24645     } catch (std::exception& e) {
24646       {
24647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24648       };
24649     } catch (...) {
24650       {
24651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24652       };
24653     }
24654   }
24655 }
24656
24657
24658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24659   void * jresult ;
24660   bool (*result)(Dali::Vector2 &) = 0 ;
24661
24662   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24663   jresult = (void *)result;
24664   return jresult;
24665 }
24666
24667
24668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24669   void * jresult ;
24670   bool (*result)(Dali::Vector2 &) = 0 ;
24671
24672   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24673   jresult = (void *)result;
24674   return jresult;
24675 }
24676
24677
24678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24679   unsigned int jresult ;
24680   bool result;
24681
24682   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24683   jresult = result;
24684   return jresult;
24685 }
24686
24687
24688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24689   unsigned int jresult ;
24690   bool result;
24691
24692   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24693   jresult = result;
24694   return jresult;
24695 }
24696
24697
24698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24699   void * jresult ;
24700   Dali::Vector4 *result = 0 ;
24701
24702   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24703   jresult = (void *)result;
24704   return jresult;
24705 }
24706
24707
24708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24709   unsigned int jresult ;
24710   bool result;
24711
24712   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24713   jresult = result;
24714   return jresult;
24715 }
24716
24717
24718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24719   unsigned int jresult ;
24720   bool result;
24721
24722   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24723   jresult = result;
24724   return jresult;
24725 }
24726
24727
24728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24729   unsigned int jresult ;
24730   unsigned int result;
24731
24732   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24733   jresult = result;
24734   return jresult;
24735 }
24736
24737
24738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24739   void * jresult ;
24740   Dali::RenderTask *result = 0 ;
24741
24742   {
24743     try {
24744       result = (Dali::RenderTask *)new Dali::RenderTask();
24745     } catch (std::out_of_range& e) {
24746       {
24747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24748       };
24749     } catch (std::exception& e) {
24750       {
24751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24752       };
24753     } catch (...) {
24754       {
24755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24756       };
24757     }
24758   }
24759   jresult = (void *)result;
24760   return jresult;
24761 }
24762
24763
24764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24765   void * jresult ;
24766   Dali::BaseHandle arg1 ;
24767   Dali::BaseHandle *argp1 ;
24768   Dali::RenderTask result;
24769
24770   argp1 = (Dali::BaseHandle *)jarg1;
24771   if (!argp1) {
24772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24773     return 0;
24774   }
24775   arg1 = *argp1;
24776   {
24777     try {
24778       result = Dali::RenderTask::DownCast(arg1);
24779     } catch (std::out_of_range& e) {
24780       {
24781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24782       };
24783     } catch (std::exception& e) {
24784       {
24785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (...) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24790       };
24791     }
24792   }
24793   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24794   return jresult;
24795 }
24796
24797
24798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24799   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24800
24801   arg1 = (Dali::RenderTask *)jarg1;
24802   {
24803     try {
24804       delete arg1;
24805     } catch (std::out_of_range& e) {
24806       {
24807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24808       };
24809     } catch (std::exception& e) {
24810       {
24811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24812       };
24813     } catch (...) {
24814       {
24815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24816       };
24817     }
24818   }
24819 }
24820
24821
24822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24823   void * jresult ;
24824   Dali::RenderTask *arg1 = 0 ;
24825   Dali::RenderTask *result = 0 ;
24826
24827   arg1 = (Dali::RenderTask *)jarg1;
24828   if (!arg1) {
24829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24830     return 0;
24831   }
24832   {
24833     try {
24834       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24835     } catch (std::out_of_range& e) {
24836       {
24837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24838       };
24839     } catch (std::exception& e) {
24840       {
24841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (...) {
24844       {
24845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24846       };
24847     }
24848   }
24849   jresult = (void *)result;
24850   return jresult;
24851 }
24852
24853
24854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24855   void * jresult ;
24856   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24857   Dali::RenderTask *arg2 = 0 ;
24858   Dali::RenderTask *result = 0 ;
24859
24860   arg1 = (Dali::RenderTask *)jarg1;
24861   arg2 = (Dali::RenderTask *)jarg2;
24862   if (!arg2) {
24863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24864     return 0;
24865   }
24866   {
24867     try {
24868       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24869     } catch (std::out_of_range& e) {
24870       {
24871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24872       };
24873     } catch (std::exception& e) {
24874       {
24875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24876       };
24877     } catch (...) {
24878       {
24879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24880       };
24881     }
24882   }
24883   jresult = (void *)result;
24884   return jresult;
24885 }
24886
24887
24888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24889   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24890   Dali::Actor arg2 ;
24891   Dali::Actor *argp2 ;
24892
24893   arg1 = (Dali::RenderTask *)jarg1;
24894   argp2 = (Dali::Actor *)jarg2;
24895   if (!argp2) {
24896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24897     return ;
24898   }
24899   arg2 = *argp2;
24900   {
24901     try {
24902       (arg1)->SetSourceActor(arg2);
24903     } catch (std::out_of_range& e) {
24904       {
24905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24906       };
24907     } catch (std::exception& e) {
24908       {
24909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24910       };
24911     } catch (...) {
24912       {
24913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24914       };
24915     }
24916   }
24917 }
24918
24919
24920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24921   void * jresult ;
24922   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24923   Dali::Actor result;
24924
24925   arg1 = (Dali::RenderTask *)jarg1;
24926   {
24927     try {
24928       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24929     } catch (std::out_of_range& e) {
24930       {
24931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24932       };
24933     } catch (std::exception& e) {
24934       {
24935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24936       };
24937     } catch (...) {
24938       {
24939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24940       };
24941     }
24942   }
24943   jresult = new Dali::Actor((const Dali::Actor &)result);
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24950   bool arg2 ;
24951
24952   arg1 = (Dali::RenderTask *)jarg1;
24953   arg2 = jarg2 ? true : false;
24954   {
24955     try {
24956       (arg1)->SetExclusive(arg2);
24957     } catch (std::out_of_range& e) {
24958       {
24959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24960       };
24961     } catch (std::exception& e) {
24962       {
24963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24964       };
24965     } catch (...) {
24966       {
24967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24968       };
24969     }
24970   }
24971 }
24972
24973
24974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24975   unsigned int jresult ;
24976   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24977   bool result;
24978
24979   arg1 = (Dali::RenderTask *)jarg1;
24980   {
24981     try {
24982       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24983     } catch (std::out_of_range& e) {
24984       {
24985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24986       };
24987     } catch (std::exception& e) {
24988       {
24989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24990       };
24991     } catch (...) {
24992       {
24993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24994       };
24995     }
24996   }
24997   jresult = result;
24998   return jresult;
24999 }
25000
25001
25002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25004   bool arg2 ;
25005
25006   arg1 = (Dali::RenderTask *)jarg1;
25007   arg2 = jarg2 ? true : false;
25008   {
25009     try {
25010       (arg1)->SetInputEnabled(arg2);
25011     } catch (std::out_of_range& e) {
25012       {
25013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25014       };
25015     } catch (std::exception& e) {
25016       {
25017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25018       };
25019     } catch (...) {
25020       {
25021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25022       };
25023     }
25024   }
25025 }
25026
25027
25028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25029   unsigned int jresult ;
25030   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25031   bool result;
25032
25033   arg1 = (Dali::RenderTask *)jarg1;
25034   {
25035     try {
25036       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25037     } catch (std::out_of_range& e) {
25038       {
25039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25040       };
25041     } catch (std::exception& e) {
25042       {
25043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25044       };
25045     } catch (...) {
25046       {
25047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25048       };
25049     }
25050   }
25051   jresult = result;
25052   return jresult;
25053 }
25054
25055
25056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25057   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25058   Dali::CameraActor arg2 ;
25059   Dali::CameraActor *argp2 ;
25060
25061   arg1 = (Dali::RenderTask *)jarg1;
25062   argp2 = (Dali::CameraActor *)jarg2;
25063   if (!argp2) {
25064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25065     return ;
25066   }
25067   arg2 = *argp2;
25068   {
25069     try {
25070       (arg1)->SetCameraActor(arg2);
25071     } catch (std::out_of_range& e) {
25072       {
25073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25074       };
25075     } catch (std::exception& e) {
25076       {
25077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25078       };
25079     } catch (...) {
25080       {
25081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25082       };
25083     }
25084   }
25085 }
25086
25087
25088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25089   void * jresult ;
25090   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25091   Dali::CameraActor result;
25092
25093   arg1 = (Dali::RenderTask *)jarg1;
25094   {
25095     try {
25096       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25097     } catch (std::out_of_range& e) {
25098       {
25099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25100       };
25101     } catch (std::exception& e) {
25102       {
25103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25104       };
25105     } catch (...) {
25106       {
25107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25108       };
25109     }
25110   }
25111   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25112   return jresult;
25113 }
25114
25115
25116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25117   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25118   Dali::FrameBufferImage arg2 ;
25119   Dali::FrameBufferImage *argp2 ;
25120
25121   arg1 = (Dali::RenderTask *)jarg1;
25122   argp2 = (Dali::FrameBufferImage *)jarg2;
25123   if (!argp2) {
25124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25125     return ;
25126   }
25127   arg2 = *argp2;
25128   {
25129     try {
25130       (arg1)->SetTargetFrameBuffer(arg2);
25131     } catch (std::out_of_range& e) {
25132       {
25133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25134       };
25135     } catch (std::exception& e) {
25136       {
25137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25138       };
25139     } catch (...) {
25140       {
25141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25142       };
25143     }
25144   }
25145 }
25146
25147
25148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25149   void * jresult ;
25150   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25151   Dali::FrameBufferImage result;
25152
25153   arg1 = (Dali::RenderTask *)jarg1;
25154   {
25155     try {
25156       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25157     } catch (std::out_of_range& e) {
25158       {
25159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (std::exception& e) {
25162       {
25163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (...) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25168       };
25169     }
25170   }
25171   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25172   return jresult;
25173 }
25174
25175
25176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25177   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25178   Dali::FrameBuffer arg2 ;
25179   Dali::FrameBuffer *argp2 ;
25180
25181   arg1 = (Dali::RenderTask *)jarg1;
25182   argp2 = (Dali::FrameBuffer *)jarg2;
25183   if (!argp2) {
25184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25185     return ;
25186   }
25187   arg2 = *argp2;
25188   {
25189     try {
25190       (arg1)->SetFrameBuffer(arg2);
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25198       };
25199     } catch (...) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25202       };
25203     }
25204   }
25205 }
25206
25207
25208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25209   void * jresult ;
25210   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25211   Dali::FrameBuffer result;
25212
25213   arg1 = (Dali::RenderTask *)jarg1;
25214   {
25215     try {
25216       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25217     } catch (std::out_of_range& e) {
25218       {
25219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25220       };
25221     } catch (std::exception& e) {
25222       {
25223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25224       };
25225     } catch (...) {
25226       {
25227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25228       };
25229     }
25230   }
25231   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25232   return jresult;
25233 }
25234
25235
25236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25237   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25238   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25239
25240   arg1 = (Dali::RenderTask *)jarg1;
25241   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25242   {
25243     try {
25244       (arg1)->SetScreenToFrameBufferFunction(arg2);
25245     } catch (std::out_of_range& e) {
25246       {
25247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25248       };
25249     } catch (std::exception& e) {
25250       {
25251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25252       };
25253     } catch (...) {
25254       {
25255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25256       };
25257     }
25258   }
25259 }
25260
25261
25262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25263   void * jresult ;
25264   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25265   Dali::RenderTask::ScreenToFrameBufferFunction result;
25266
25267   arg1 = (Dali::RenderTask *)jarg1;
25268   {
25269     try {
25270       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25271     } catch (std::out_of_range& e) {
25272       {
25273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25274       };
25275     } catch (std::exception& e) {
25276       {
25277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25278       };
25279     } catch (...) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25282       };
25283     }
25284   }
25285   jresult = (void *)result;
25286   return jresult;
25287 }
25288
25289
25290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25291   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25292   Dali::Actor arg2 ;
25293   Dali::Actor *argp2 ;
25294
25295   arg1 = (Dali::RenderTask *)jarg1;
25296   argp2 = (Dali::Actor *)jarg2;
25297   if (!argp2) {
25298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25299     return ;
25300   }
25301   arg2 = *argp2;
25302   {
25303     try {
25304       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25305     } catch (std::out_of_range& e) {
25306       {
25307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25308       };
25309     } catch (std::exception& e) {
25310       {
25311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25312       };
25313     } catch (...) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25316       };
25317     }
25318   }
25319 }
25320
25321
25322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25323   void * jresult ;
25324   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25325   Dali::Actor result;
25326
25327   arg1 = (Dali::RenderTask *)jarg1;
25328   {
25329     try {
25330       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25331     } catch (std::out_of_range& e) {
25332       {
25333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25334       };
25335     } catch (std::exception& e) {
25336       {
25337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25338       };
25339     } catch (...) {
25340       {
25341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25342       };
25343     }
25344   }
25345   jresult = new Dali::Actor((const Dali::Actor &)result);
25346   return jresult;
25347 }
25348
25349
25350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25351   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25352   Dali::Vector2 arg2 ;
25353   Dali::Vector2 *argp2 ;
25354
25355   arg1 = (Dali::RenderTask *)jarg1;
25356   argp2 = (Dali::Vector2 *)jarg2;
25357   if (!argp2) {
25358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25359     return ;
25360   }
25361   arg2 = *argp2;
25362   {
25363     try {
25364       (arg1)->SetViewportPosition(arg2);
25365     } catch (std::out_of_range& e) {
25366       {
25367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25368       };
25369     } catch (std::exception& e) {
25370       {
25371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25372       };
25373     } catch (...) {
25374       {
25375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25376       };
25377     }
25378   }
25379 }
25380
25381
25382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25383   void * jresult ;
25384   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25385   Dali::Vector2 result;
25386
25387   arg1 = (Dali::RenderTask *)jarg1;
25388   {
25389     try {
25390       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25391     } catch (std::out_of_range& e) {
25392       {
25393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25394       };
25395     } catch (std::exception& e) {
25396       {
25397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25398       };
25399     } catch (...) {
25400       {
25401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25402       };
25403     }
25404   }
25405   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25406   return jresult;
25407 }
25408
25409
25410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25411   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25412   Dali::Vector2 arg2 ;
25413   Dali::Vector2 *argp2 ;
25414
25415   arg1 = (Dali::RenderTask *)jarg1;
25416   argp2 = (Dali::Vector2 *)jarg2;
25417   if (!argp2) {
25418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25419     return ;
25420   }
25421   arg2 = *argp2;
25422   {
25423     try {
25424       (arg1)->SetViewportSize(arg2);
25425     } catch (std::out_of_range& e) {
25426       {
25427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25428       };
25429     } catch (std::exception& e) {
25430       {
25431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25432       };
25433     } catch (...) {
25434       {
25435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25436       };
25437     }
25438   }
25439 }
25440
25441
25442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25443   void * jresult ;
25444   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25445   Dali::Vector2 result;
25446
25447   arg1 = (Dali::RenderTask *)jarg1;
25448   {
25449     try {
25450       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25451     } catch (std::out_of_range& e) {
25452       {
25453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25454       };
25455     } catch (std::exception& e) {
25456       {
25457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25458       };
25459     } catch (...) {
25460       {
25461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25462       };
25463     }
25464   }
25465   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25466   return jresult;
25467 }
25468
25469
25470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25472   Dali::Viewport arg2 ;
25473   Dali::Viewport *argp2 ;
25474
25475   arg1 = (Dali::RenderTask *)jarg1;
25476   argp2 = (Dali::Viewport *)jarg2;
25477   if (!argp2) {
25478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25479     return ;
25480   }
25481   arg2 = *argp2;
25482   {
25483     try {
25484       (arg1)->SetViewport(arg2);
25485     } catch (std::out_of_range& e) {
25486       {
25487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25488       };
25489     } catch (std::exception& e) {
25490       {
25491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25492       };
25493     } catch (...) {
25494       {
25495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25496       };
25497     }
25498   }
25499 }
25500
25501
25502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25503   void * jresult ;
25504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25505   Dali::Viewport result;
25506
25507   arg1 = (Dali::RenderTask *)jarg1;
25508   {
25509     try {
25510       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25511     } catch (std::out_of_range& e) {
25512       {
25513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25514       };
25515     } catch (std::exception& e) {
25516       {
25517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25518       };
25519     } catch (...) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25522       };
25523     }
25524   }
25525   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25526   return jresult;
25527 }
25528
25529
25530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25532   Dali::Vector4 *arg2 = 0 ;
25533
25534   arg1 = (Dali::RenderTask *)jarg1;
25535   arg2 = (Dali::Vector4 *)jarg2;
25536   if (!arg2) {
25537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25538     return ;
25539   }
25540   {
25541     try {
25542       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25543     } catch (std::out_of_range& e) {
25544       {
25545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25546       };
25547     } catch (std::exception& e) {
25548       {
25549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25550       };
25551     } catch (...) {
25552       {
25553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25554       };
25555     }
25556   }
25557 }
25558
25559
25560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25561   void * jresult ;
25562   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25563   Dali::Vector4 result;
25564
25565   arg1 = (Dali::RenderTask *)jarg1;
25566   {
25567     try {
25568       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25569     } catch (std::out_of_range& e) {
25570       {
25571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25572       };
25573     } catch (std::exception& e) {
25574       {
25575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25576       };
25577     } catch (...) {
25578       {
25579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25580       };
25581     }
25582   }
25583   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25584   return jresult;
25585 }
25586
25587
25588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25590   bool arg2 ;
25591
25592   arg1 = (Dali::RenderTask *)jarg1;
25593   arg2 = jarg2 ? true : false;
25594   {
25595     try {
25596       (arg1)->SetClearEnabled(arg2);
25597     } catch (std::out_of_range& e) {
25598       {
25599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25600       };
25601     } catch (std::exception& e) {
25602       {
25603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25604       };
25605     } catch (...) {
25606       {
25607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25608       };
25609     }
25610   }
25611 }
25612
25613
25614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25615   unsigned int jresult ;
25616   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25617   bool result;
25618
25619   arg1 = (Dali::RenderTask *)jarg1;
25620   {
25621     try {
25622       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25623     } catch (std::out_of_range& e) {
25624       {
25625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (std::exception& e) {
25628       {
25629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (...) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25634       };
25635     }
25636   }
25637   jresult = result;
25638   return jresult;
25639 }
25640
25641
25642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25644   bool arg2 ;
25645
25646   arg1 = (Dali::RenderTask *)jarg1;
25647   arg2 = jarg2 ? true : false;
25648   {
25649     try {
25650       (arg1)->SetCullMode(arg2);
25651     } catch (std::out_of_range& e) {
25652       {
25653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25654       };
25655     } catch (std::exception& e) {
25656       {
25657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25658       };
25659     } catch (...) {
25660       {
25661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25662       };
25663     }
25664   }
25665 }
25666
25667
25668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25669   unsigned int jresult ;
25670   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25671   bool result;
25672
25673   arg1 = (Dali::RenderTask *)jarg1;
25674   {
25675     try {
25676       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25677     } catch (std::out_of_range& e) {
25678       {
25679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25680       };
25681     } catch (std::exception& e) {
25682       {
25683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25684       };
25685     } catch (...) {
25686       {
25687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25688       };
25689     }
25690   }
25691   jresult = result;
25692   return jresult;
25693 }
25694
25695
25696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25698   unsigned int arg2 ;
25699
25700   arg1 = (Dali::RenderTask *)jarg1;
25701   arg2 = (unsigned int)jarg2;
25702   {
25703     try {
25704       (arg1)->SetRefreshRate(arg2);
25705     } catch (std::out_of_range& e) {
25706       {
25707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25708       };
25709     } catch (std::exception& e) {
25710       {
25711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25712       };
25713     } catch (...) {
25714       {
25715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25716       };
25717     }
25718   }
25719 }
25720
25721
25722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25723   unsigned int jresult ;
25724   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25725   unsigned int result;
25726
25727   arg1 = (Dali::RenderTask *)jarg1;
25728   {
25729     try {
25730       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25731     } catch (std::out_of_range& e) {
25732       {
25733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25734       };
25735     } catch (std::exception& e) {
25736       {
25737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25738       };
25739     } catch (...) {
25740       {
25741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25742       };
25743     }
25744   }
25745   jresult = result;
25746   return jresult;
25747 }
25748
25749
25750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25751   unsigned int jresult ;
25752   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25753   Dali::Vector3 *arg2 = 0 ;
25754   float *arg3 = 0 ;
25755   float *arg4 = 0 ;
25756   bool result;
25757
25758   arg1 = (Dali::RenderTask *)jarg1;
25759   arg2 = (Dali::Vector3 *)jarg2;
25760   if (!arg2) {
25761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25762     return 0;
25763   }
25764   arg3 = (float *)jarg3;
25765   arg4 = (float *)jarg4;
25766   {
25767     try {
25768       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25769     } catch (std::out_of_range& e) {
25770       {
25771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25772       };
25773     } catch (std::exception& e) {
25774       {
25775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25776       };
25777     } catch (...) {
25778       {
25779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25780       };
25781     }
25782   }
25783   jresult = result;
25784   return jresult;
25785 }
25786
25787
25788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25789   unsigned int jresult ;
25790   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25791   Dali::Actor arg2 ;
25792   float arg3 ;
25793   float arg4 ;
25794   float *arg5 = 0 ;
25795   float *arg6 = 0 ;
25796   Dali::Actor *argp2 ;
25797   bool result;
25798
25799   arg1 = (Dali::RenderTask *)jarg1;
25800   argp2 = (Dali::Actor *)jarg2;
25801   if (!argp2) {
25802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25803     return 0;
25804   }
25805   arg2 = *argp2;
25806   arg3 = (float)jarg3;
25807   arg4 = (float)jarg4;
25808   arg5 = (float *)jarg5;
25809   arg6 = (float *)jarg6;
25810   {
25811     try {
25812       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25813     } catch (std::out_of_range& e) {
25814       {
25815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25816       };
25817     } catch (std::exception& e) {
25818       {
25819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (...) {
25822       {
25823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25824       };
25825     }
25826   }
25827   jresult = result;
25828   return jresult;
25829 }
25830
25831
25832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25833   void * jresult ;
25834   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25835   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25836
25837   arg1 = (Dali::RenderTask *)jarg1;
25838   {
25839     try {
25840       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25841     } catch (std::out_of_range& e) {
25842       {
25843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25844       };
25845     } catch (std::exception& e) {
25846       {
25847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25848       };
25849     } catch (...) {
25850       {
25851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25852       };
25853     }
25854   }
25855   jresult = (void *)result;
25856   return jresult;
25857 }
25858
25859
25860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25861   void * jresult ;
25862   int arg1 ;
25863   Dali::TouchPoint::State arg2 ;
25864   float arg3 ;
25865   float arg4 ;
25866   Dali::TouchPoint *result = 0 ;
25867
25868   arg1 = (int)jarg1;
25869   arg2 = (Dali::TouchPoint::State)jarg2;
25870   arg3 = (float)jarg3;
25871   arg4 = (float)jarg4;
25872   {
25873     try {
25874       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25875     } catch (std::out_of_range& e) {
25876       {
25877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25878       };
25879     } catch (std::exception& e) {
25880       {
25881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25882       };
25883     } catch (...) {
25884       {
25885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25886       };
25887     }
25888   }
25889   jresult = (void *)result;
25890   return jresult;
25891 }
25892
25893
25894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25895   void * jresult ;
25896   int arg1 ;
25897   Dali::TouchPoint::State arg2 ;
25898   float arg3 ;
25899   float arg4 ;
25900   float arg5 ;
25901   float arg6 ;
25902   Dali::TouchPoint *result = 0 ;
25903
25904   arg1 = (int)jarg1;
25905   arg2 = (Dali::TouchPoint::State)jarg2;
25906   arg3 = (float)jarg3;
25907   arg4 = (float)jarg4;
25908   arg5 = (float)jarg5;
25909   arg6 = (float)jarg6;
25910   {
25911     try {
25912       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25913     } catch (std::out_of_range& e) {
25914       {
25915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25916       };
25917     } catch (std::exception& e) {
25918       {
25919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25920       };
25921     } catch (...) {
25922       {
25923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25924       };
25925     }
25926   }
25927   jresult = (void *)result;
25928   return jresult;
25929 }
25930
25931
25932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25933   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25934
25935   arg1 = (Dali::TouchPoint *)jarg1;
25936   {
25937     try {
25938       delete arg1;
25939     } catch (std::out_of_range& e) {
25940       {
25941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25942       };
25943     } catch (std::exception& e) {
25944       {
25945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25946       };
25947     } catch (...) {
25948       {
25949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25950       };
25951     }
25952   }
25953 }
25954
25955
25956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25957   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25958   int arg2 ;
25959
25960   arg1 = (Dali::TouchPoint *)jarg1;
25961   arg2 = (int)jarg2;
25962   if (arg1) (arg1)->deviceId = arg2;
25963 }
25964
25965
25966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25967   int jresult ;
25968   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25969   int result;
25970
25971   arg1 = (Dali::TouchPoint *)jarg1;
25972   result = (int) ((arg1)->deviceId);
25973   jresult = result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25979   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25980   Dali::TouchPoint::State arg2 ;
25981
25982   arg1 = (Dali::TouchPoint *)jarg1;
25983   arg2 = (Dali::TouchPoint::State)jarg2;
25984   if (arg1) (arg1)->state = arg2;
25985 }
25986
25987
25988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25989   int jresult ;
25990   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25991   Dali::TouchPoint::State result;
25992
25993   arg1 = (Dali::TouchPoint *)jarg1;
25994   result = (Dali::TouchPoint::State) ((arg1)->state);
25995   jresult = (int)result;
25996   return jresult;
25997 }
25998
25999
26000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26001   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26002   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26003
26004   arg1 = (Dali::TouchPoint *)jarg1;
26005   arg2 = (Dali::Actor *)jarg2;
26006   if (arg1) (arg1)->hitActor = *arg2;
26007 }
26008
26009
26010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26011   void * jresult ;
26012   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26013   Dali::Actor *result = 0 ;
26014
26015   arg1 = (Dali::TouchPoint *)jarg1;
26016   result = (Dali::Actor *)& ((arg1)->hitActor);
26017   jresult = (void *)result;
26018   return jresult;
26019 }
26020
26021
26022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26023   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26024   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26025
26026   arg1 = (Dali::TouchPoint *)jarg1;
26027   arg2 = (Dali::Vector2 *)jarg2;
26028   if (arg1) (arg1)->local = *arg2;
26029 }
26030
26031
26032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26033   void * jresult ;
26034   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26035   Dali::Vector2 *result = 0 ;
26036
26037   arg1 = (Dali::TouchPoint *)jarg1;
26038   result = (Dali::Vector2 *)& ((arg1)->local);
26039   jresult = (void *)result;
26040   return jresult;
26041 }
26042
26043
26044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26045   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26046   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26047
26048   arg1 = (Dali::TouchPoint *)jarg1;
26049   arg2 = (Dali::Vector2 *)jarg2;
26050   if (arg1) (arg1)->screen = *arg2;
26051 }
26052
26053
26054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26055   void * jresult ;
26056   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26057   Dali::Vector2 *result = 0 ;
26058
26059   arg1 = (Dali::TouchPoint *)jarg1;
26060   result = (Dali::Vector2 *)& ((arg1)->screen);
26061   jresult = (void *)result;
26062   return jresult;
26063 }
26064
26065
26066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26067   void * jresult ;
26068   Dali::TouchData *result = 0 ;
26069
26070   {
26071     try {
26072       result = (Dali::TouchData *)new Dali::TouchData();
26073     } catch (std::out_of_range& e) {
26074       {
26075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26076       };
26077     } catch (std::exception& e) {
26078       {
26079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26080       };
26081     } catch (...) {
26082       {
26083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26084       };
26085     }
26086   }
26087   jresult = (void *)result;
26088   return jresult;
26089 }
26090
26091
26092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26093   void * jresult ;
26094   Dali::TouchData *arg1 = 0 ;
26095   Dali::TouchData *result = 0 ;
26096
26097   arg1 = (Dali::TouchData *)jarg1;
26098   if (!arg1) {
26099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26100     return 0;
26101   }
26102   {
26103     try {
26104       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26105     } catch (std::out_of_range& e) {
26106       {
26107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26108       };
26109     } catch (std::exception& e) {
26110       {
26111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26112       };
26113     } catch (...) {
26114       {
26115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26116       };
26117     }
26118   }
26119   jresult = (void *)result;
26120   return jresult;
26121 }
26122
26123
26124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26125   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26126
26127   arg1 = (Dali::TouchData *)jarg1;
26128   {
26129     try {
26130       delete arg1;
26131     } catch (std::out_of_range& e) {
26132       {
26133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26134       };
26135     } catch (std::exception& e) {
26136       {
26137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26138       };
26139     } catch (...) {
26140       {
26141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26142       };
26143     }
26144   }
26145 }
26146
26147
26148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26149   void * jresult ;
26150   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26151   Dali::TouchData *arg2 = 0 ;
26152   Dali::TouchData *result = 0 ;
26153
26154   arg1 = (Dali::TouchData *)jarg1;
26155   arg2 = (Dali::TouchData *)jarg2;
26156   if (!arg2) {
26157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26158     return 0;
26159   }
26160   {
26161     try {
26162       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26163     } catch (std::out_of_range& e) {
26164       {
26165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26166       };
26167     } catch (std::exception& e) {
26168       {
26169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26170       };
26171     } catch (...) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26174       };
26175     }
26176   }
26177   jresult = (void *)result;
26178   return jresult;
26179 }
26180
26181
26182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26183   unsigned long jresult ;
26184   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26185   unsigned long result;
26186
26187   arg1 = (Dali::TouchData *)jarg1;
26188   {
26189     try {
26190       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26191     } catch (std::out_of_range& e) {
26192       {
26193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26194       };
26195     } catch (std::exception& e) {
26196       {
26197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26198       };
26199     } catch (...) {
26200       {
26201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26202       };
26203     }
26204   }
26205   jresult = (unsigned long)result;
26206   return jresult;
26207 }
26208
26209
26210 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26211   unsigned long jresult ;
26212   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26213   std::size_t result;
26214
26215   arg1 = (Dali::TouchData *)jarg1;
26216   {
26217     try {
26218       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26219     } catch (std::out_of_range& e) {
26220       {
26221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26222       };
26223     } catch (std::exception& e) {
26224       {
26225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26226       };
26227     } catch (...) {
26228       {
26229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26230       };
26231     }
26232   }
26233   jresult = (unsigned long)result;
26234   return jresult;
26235 }
26236
26237
26238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26239   int jresult ;
26240   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26241   std::size_t arg2 ;
26242   int32_t result;
26243
26244   arg1 = (Dali::TouchData *)jarg1;
26245   arg2 = (std::size_t)jarg2;
26246   {
26247     try {
26248       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26249     } catch (std::out_of_range& e) {
26250       {
26251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26252       };
26253     } catch (std::exception& e) {
26254       {
26255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26256       };
26257     } catch (...) {
26258       {
26259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26260       };
26261     }
26262   }
26263   jresult = result;
26264   return jresult;
26265 }
26266
26267
26268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26269   int jresult ;
26270   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26271   std::size_t arg2 ;
26272   Dali::PointState::Type result;
26273
26274   arg1 = (Dali::TouchData *)jarg1;
26275   arg2 = (std::size_t)jarg2;
26276   {
26277     try {
26278       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26279     } catch (std::out_of_range& e) {
26280       {
26281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (std::exception& e) {
26284       {
26285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26286       };
26287     } catch (...) {
26288       {
26289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26290       };
26291     }
26292   }
26293   jresult = (int)result;
26294   return jresult;
26295 }
26296
26297
26298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26299   void * jresult ;
26300   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26301   std::size_t arg2 ;
26302   Dali::Actor result;
26303
26304   arg1 = (Dali::TouchData *)jarg1;
26305   arg2 = (std::size_t)jarg2;
26306   {
26307     try {
26308       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26309     } catch (std::out_of_range& e) {
26310       {
26311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26312       };
26313     } catch (std::exception& e) {
26314       {
26315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26316       };
26317     } catch (...) {
26318       {
26319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26320       };
26321     }
26322   }
26323   jresult = new Dali::Actor((const Dali::Actor &)result);
26324   return jresult;
26325 }
26326
26327
26328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26329   void * jresult ;
26330   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26331   std::size_t arg2 ;
26332   Dali::Vector2 *result = 0 ;
26333
26334   arg1 = (Dali::TouchData *)jarg1;
26335   arg2 = (std::size_t)jarg2;
26336   {
26337     try {
26338       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26339     } catch (std::out_of_range& e) {
26340       {
26341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26342       };
26343     } catch (std::exception& e) {
26344       {
26345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26346       };
26347     } catch (...) {
26348       {
26349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26350       };
26351     }
26352   }
26353   jresult = (void *)result;
26354   return jresult;
26355 }
26356
26357
26358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26359   void * jresult ;
26360   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26361   std::size_t arg2 ;
26362   Dali::Vector2 *result = 0 ;
26363
26364   arg1 = (Dali::TouchData *)jarg1;
26365   arg2 = (std::size_t)jarg2;
26366   {
26367     try {
26368       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26369     } catch (std::out_of_range& e) {
26370       {
26371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26372       };
26373     } catch (std::exception& e) {
26374       {
26375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26376       };
26377     } catch (...) {
26378       {
26379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26380       };
26381     }
26382   }
26383   jresult = (void *)result;
26384   return jresult;
26385 }
26386
26387
26388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26389   float jresult ;
26390   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26391   std::size_t arg2 ;
26392   float result;
26393
26394   arg1 = (Dali::TouchData *)jarg1;
26395   arg2 = (std::size_t)jarg2;
26396   {
26397     try {
26398       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26399     } catch (std::out_of_range& e) {
26400       {
26401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26402       };
26403     } catch (std::exception& e) {
26404       {
26405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26406       };
26407     } catch (...) {
26408       {
26409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26410       };
26411     }
26412   }
26413   jresult = result;
26414   return jresult;
26415 }
26416
26417
26418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26419   void * jresult ;
26420   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26421   std::size_t arg2 ;
26422   Dali::Vector2 *result = 0 ;
26423
26424   arg1 = (Dali::TouchData *)jarg1;
26425   arg2 = (std::size_t)jarg2;
26426   {
26427     try {
26428       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26429     } catch (std::out_of_range& e) {
26430       {
26431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (std::exception& e) {
26434       {
26435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (...) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26440       };
26441     }
26442   }
26443   jresult = (void *)result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26449   float jresult ;
26450   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26451   std::size_t arg2 ;
26452   float result;
26453
26454   arg1 = (Dali::TouchData *)jarg1;
26455   arg2 = (std::size_t)jarg2;
26456   {
26457     try {
26458       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26459     } catch (std::out_of_range& e) {
26460       {
26461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26462       };
26463     } catch (std::exception& e) {
26464       {
26465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26466       };
26467     } catch (...) {
26468       {
26469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26470       };
26471     }
26472   }
26473   jresult = result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26479   void * jresult ;
26480   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26481   std::size_t arg2 ;
26482   Dali::Degree result;
26483
26484   arg1 = (Dali::TouchData *)jarg1;
26485   arg2 = (std::size_t)jarg2;
26486   {
26487     try {
26488       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26489     } catch (std::out_of_range& e) {
26490       {
26491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26492       };
26493     } catch (std::exception& e) {
26494       {
26495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26496       };
26497     } catch (...) {
26498       {
26499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26500       };
26501     }
26502   }
26503   jresult = new Dali::Degree((const Dali::Degree &)result);
26504   return jresult;
26505 }
26506
26507
26508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26509   void * jresult ;
26510   Dali::GestureDetector *result = 0 ;
26511
26512   {
26513     try {
26514       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26515     } catch (std::out_of_range& e) {
26516       {
26517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26518       };
26519     } catch (std::exception& e) {
26520       {
26521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26522       };
26523     } catch (...) {
26524       {
26525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26526       };
26527     }
26528   }
26529   jresult = (void *)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26535   void * jresult ;
26536   Dali::BaseHandle arg1 ;
26537   Dali::BaseHandle *argp1 ;
26538   Dali::GestureDetector result;
26539
26540   argp1 = (Dali::BaseHandle *)jarg1;
26541   if (!argp1) {
26542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26543     return 0;
26544   }
26545   arg1 = *argp1;
26546   {
26547     try {
26548       result = Dali::GestureDetector::DownCast(arg1);
26549     } catch (std::out_of_range& e) {
26550       {
26551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26552       };
26553     } catch (std::exception& e) {
26554       {
26555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26556       };
26557     } catch (...) {
26558       {
26559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26560       };
26561     }
26562   }
26563   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26564   return jresult;
26565 }
26566
26567
26568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26569   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26570
26571   arg1 = (Dali::GestureDetector *)jarg1;
26572   {
26573     try {
26574       delete arg1;
26575     } catch (std::out_of_range& e) {
26576       {
26577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26578       };
26579     } catch (std::exception& e) {
26580       {
26581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26582       };
26583     } catch (...) {
26584       {
26585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26586       };
26587     }
26588   }
26589 }
26590
26591
26592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26593   void * jresult ;
26594   Dali::GestureDetector *arg1 = 0 ;
26595   Dali::GestureDetector *result = 0 ;
26596
26597   arg1 = (Dali::GestureDetector *)jarg1;
26598   if (!arg1) {
26599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26600     return 0;
26601   }
26602   {
26603     try {
26604       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26605     } catch (std::out_of_range& e) {
26606       {
26607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26608       };
26609     } catch (std::exception& e) {
26610       {
26611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26612       };
26613     } catch (...) {
26614       {
26615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26616       };
26617     }
26618   }
26619   jresult = (void *)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26625   void * jresult ;
26626   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26627   Dali::GestureDetector *arg2 = 0 ;
26628   Dali::GestureDetector *result = 0 ;
26629
26630   arg1 = (Dali::GestureDetector *)jarg1;
26631   arg2 = (Dali::GestureDetector *)jarg2;
26632   if (!arg2) {
26633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26634     return 0;
26635   }
26636   {
26637     try {
26638       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26639     } catch (std::out_of_range& e) {
26640       {
26641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26642       };
26643     } catch (std::exception& e) {
26644       {
26645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26646       };
26647     } catch (...) {
26648       {
26649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26650       };
26651     }
26652   }
26653   jresult = (void *)result;
26654   return jresult;
26655 }
26656
26657
26658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26659   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26660   Dali::Actor arg2 ;
26661   Dali::Actor *argp2 ;
26662
26663   arg1 = (Dali::GestureDetector *)jarg1;
26664   argp2 = (Dali::Actor *)jarg2;
26665   if (!argp2) {
26666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26667     return ;
26668   }
26669   arg2 = *argp2;
26670   {
26671     try {
26672       (arg1)->Attach(arg2);
26673     } catch (std::out_of_range& e) {
26674       {
26675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26676       };
26677     } catch (std::exception& e) {
26678       {
26679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26680       };
26681     } catch (...) {
26682       {
26683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26684       };
26685     }
26686   }
26687 }
26688
26689
26690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26691   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26692   Dali::Actor arg2 ;
26693   Dali::Actor *argp2 ;
26694
26695   arg1 = (Dali::GestureDetector *)jarg1;
26696   argp2 = (Dali::Actor *)jarg2;
26697   if (!argp2) {
26698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26699     return ;
26700   }
26701   arg2 = *argp2;
26702   {
26703     try {
26704       (arg1)->Detach(arg2);
26705     } catch (std::out_of_range& e) {
26706       {
26707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26708       };
26709     } catch (std::exception& e) {
26710       {
26711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26712       };
26713     } catch (...) {
26714       {
26715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26716       };
26717     }
26718   }
26719 }
26720
26721
26722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26723   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26724
26725   arg1 = (Dali::GestureDetector *)jarg1;
26726   {
26727     try {
26728       (arg1)->DetachAll();
26729     } catch (std::out_of_range& e) {
26730       {
26731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26732       };
26733     } catch (std::exception& e) {
26734       {
26735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26736       };
26737     } catch (...) {
26738       {
26739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26740       };
26741     }
26742   }
26743 }
26744
26745
26746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26747   unsigned long jresult ;
26748   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26749   size_t result;
26750
26751   arg1 = (Dali::GestureDetector *)jarg1;
26752   {
26753     try {
26754       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26755     } catch (std::out_of_range& e) {
26756       {
26757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26758       };
26759     } catch (std::exception& e) {
26760       {
26761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26762       };
26763     } catch (...) {
26764       {
26765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26766       };
26767     }
26768   }
26769   jresult = (unsigned long)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26775   void * jresult ;
26776   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26777   size_t arg2 ;
26778   Dali::Actor result;
26779
26780   arg1 = (Dali::GestureDetector *)jarg1;
26781   arg2 = (size_t)jarg2;
26782   {
26783     try {
26784       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26785     } catch (std::out_of_range& e) {
26786       {
26787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26788       };
26789     } catch (std::exception& e) {
26790       {
26791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26792       };
26793     } catch (...) {
26794       {
26795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26796       };
26797     }
26798   }
26799   jresult = new Dali::Actor((const Dali::Actor &)result);
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26805   void * jresult ;
26806   Dali::Gesture *arg1 = 0 ;
26807   Dali::Gesture *result = 0 ;
26808
26809   arg1 = (Dali::Gesture *)jarg1;
26810   if (!arg1) {
26811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26812     return 0;
26813   }
26814   {
26815     try {
26816       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26817     } catch (std::out_of_range& e) {
26818       {
26819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26820       };
26821     } catch (std::exception& e) {
26822       {
26823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26824       };
26825     } catch (...) {
26826       {
26827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26828       };
26829     }
26830   }
26831   jresult = (void *)result;
26832   return jresult;
26833 }
26834
26835
26836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26837   void * jresult ;
26838   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26839   Dali::Gesture *arg2 = 0 ;
26840   Dali::Gesture *result = 0 ;
26841
26842   arg1 = (Dali::Gesture *)jarg1;
26843   arg2 = (Dali::Gesture *)jarg2;
26844   if (!arg2) {
26845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26846     return 0;
26847   }
26848   {
26849     try {
26850       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26851     } catch (std::out_of_range& e) {
26852       {
26853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26854       };
26855     } catch (std::exception& e) {
26856       {
26857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26858       };
26859     } catch (...) {
26860       {
26861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26862       };
26863     }
26864   }
26865   jresult = (void *)result;
26866   return jresult;
26867 }
26868
26869
26870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26871   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26872
26873   arg1 = (Dali::Gesture *)jarg1;
26874   {
26875     try {
26876       delete arg1;
26877     } catch (std::out_of_range& e) {
26878       {
26879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26880       };
26881     } catch (std::exception& e) {
26882       {
26883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26884       };
26885     } catch (...) {
26886       {
26887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26888       };
26889     }
26890   }
26891 }
26892
26893
26894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26895   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26896   Dali::Gesture::Type arg2 ;
26897
26898   arg1 = (Dali::Gesture *)jarg1;
26899   arg2 = (Dali::Gesture::Type)jarg2;
26900   if (arg1) (arg1)->type = arg2;
26901 }
26902
26903
26904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26905   int jresult ;
26906   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26907   Dali::Gesture::Type result;
26908
26909   arg1 = (Dali::Gesture *)jarg1;
26910   result = (Dali::Gesture::Type) ((arg1)->type);
26911   jresult = (int)result;
26912   return jresult;
26913 }
26914
26915
26916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26917   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26918   Dali::Gesture::State arg2 ;
26919
26920   arg1 = (Dali::Gesture *)jarg1;
26921   arg2 = (Dali::Gesture::State)jarg2;
26922   if (arg1) (arg1)->state = arg2;
26923 }
26924
26925
26926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26927   int jresult ;
26928   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26929   Dali::Gesture::State result;
26930
26931   arg1 = (Dali::Gesture *)jarg1;
26932   result = (Dali::Gesture::State) ((arg1)->state);
26933   jresult = (int)result;
26934   return jresult;
26935 }
26936
26937
26938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26939   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26940   unsigned int arg2 ;
26941
26942   arg1 = (Dali::Gesture *)jarg1;
26943   arg2 = (unsigned int)jarg2;
26944   if (arg1) (arg1)->time = arg2;
26945 }
26946
26947
26948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26949   unsigned int jresult ;
26950   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26951   unsigned int result;
26952
26953   arg1 = (Dali::Gesture *)jarg1;
26954   result = (unsigned int) ((arg1)->time);
26955   jresult = result;
26956   return jresult;
26957 }
26958
26959
26960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26961   void * jresult ;
26962   Dali::HoverEvent *result = 0 ;
26963
26964   {
26965     try {
26966       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26967     } catch (std::out_of_range& e) {
26968       {
26969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26970       };
26971     } catch (std::exception& e) {
26972       {
26973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26974       };
26975     } catch (...) {
26976       {
26977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26978       };
26979     }
26980   }
26981   jresult = (void *)result;
26982   return jresult;
26983 }
26984
26985
26986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26987   void * jresult ;
26988   unsigned long arg1 ;
26989   Dali::HoverEvent *result = 0 ;
26990
26991   arg1 = (unsigned long)jarg1;
26992   {
26993     try {
26994       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26995     } catch (std::out_of_range& e) {
26996       {
26997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26998       };
26999     } catch (std::exception& e) {
27000       {
27001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27002       };
27003     } catch (...) {
27004       {
27005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27006       };
27007     }
27008   }
27009   jresult = (void *)result;
27010   return jresult;
27011 }
27012
27013
27014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27015   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27016
27017   arg1 = (Dali::HoverEvent *)jarg1;
27018   {
27019     try {
27020       delete arg1;
27021     } catch (std::out_of_range& e) {
27022       {
27023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27024       };
27025     } catch (std::exception& e) {
27026       {
27027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27028       };
27029     } catch (...) {
27030       {
27031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27032       };
27033     }
27034   }
27035 }
27036
27037
27038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27039   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27040   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27041
27042   arg1 = (Dali::HoverEvent *)jarg1;
27043   arg2 = (Dali::TouchPointContainer *)jarg2;
27044   if (arg1) (arg1)->points = *arg2;
27045 }
27046
27047
27048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27049   void * jresult ;
27050   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27051   Dali::TouchPointContainer *result = 0 ;
27052
27053   arg1 = (Dali::HoverEvent *)jarg1;
27054   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27055   jresult = (void *)result;
27056   return jresult;
27057 }
27058
27059
27060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27061   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27062   unsigned long arg2 ;
27063
27064   arg1 = (Dali::HoverEvent *)jarg1;
27065   arg2 = (unsigned long)jarg2;
27066   if (arg1) (arg1)->time = arg2;
27067 }
27068
27069
27070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27071   unsigned long jresult ;
27072   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27073   unsigned long result;
27074
27075   arg1 = (Dali::HoverEvent *)jarg1;
27076   result = (unsigned long) ((arg1)->time);
27077   jresult = (unsigned long)result;
27078   return jresult;
27079 }
27080
27081
27082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27083   unsigned int jresult ;
27084   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27085   unsigned int result;
27086
27087   arg1 = (Dali::HoverEvent *)jarg1;
27088   {
27089     try {
27090       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27091     } catch (std::out_of_range& e) {
27092       {
27093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27094       };
27095     } catch (std::exception& e) {
27096       {
27097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27098       };
27099     } catch (...) {
27100       {
27101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27102       };
27103     }
27104   }
27105   jresult = result;
27106   return jresult;
27107 }
27108
27109
27110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27111   void * jresult ;
27112   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27113   unsigned int arg2 ;
27114   Dali::TouchPoint *result = 0 ;
27115
27116   arg1 = (Dali::HoverEvent *)jarg1;
27117   arg2 = (unsigned int)jarg2;
27118   {
27119     try {
27120       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27128       };
27129     } catch (...) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27132       };
27133     }
27134   }
27135   jresult = (void *)result;
27136   return jresult;
27137 }
27138
27139
27140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27141   void * jresult ;
27142   Dali::KeyEvent *result = 0 ;
27143
27144   {
27145     try {
27146       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27147     } catch (std::out_of_range& e) {
27148       {
27149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27150       };
27151     } catch (std::exception& e) {
27152       {
27153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27154       };
27155     } catch (...) {
27156       {
27157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27158       };
27159     }
27160   }
27161   jresult = (void *)result;
27162   return jresult;
27163 }
27164
27165
27166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27167   void * jresult ;
27168   std::string *arg1 = 0 ;
27169   std::string *arg2 = 0 ;
27170   int arg3 ;
27171   int arg4 ;
27172   unsigned long arg5 ;
27173   Dali::KeyEvent::State *arg6 = 0 ;
27174   Dali::KeyEvent::State temp6 ;
27175   Dali::KeyEvent *result = 0 ;
27176
27177   if (!jarg1) {
27178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27179     return 0;
27180   }
27181   std::string arg1_str(jarg1);
27182   arg1 = &arg1_str;
27183   if (!jarg2) {
27184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27185     return 0;
27186   }
27187   std::string arg2_str(jarg2);
27188   arg2 = &arg2_str;
27189   arg3 = (int)jarg3;
27190   arg4 = (int)jarg4;
27191   arg5 = (unsigned long)jarg5;
27192   temp6 = (Dali::KeyEvent::State)jarg6;
27193   arg6 = &temp6;
27194   {
27195     try {
27196       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27197     } catch (std::out_of_range& e) {
27198       {
27199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27200       };
27201     } catch (std::exception& e) {
27202       {
27203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27204       };
27205     } catch (...) {
27206       {
27207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27208       };
27209     }
27210   }
27211   jresult = (void *)result;
27212
27213   //argout typemap for const std::string&
27214
27215
27216   //argout typemap for const std::string&
27217
27218   return jresult;
27219 }
27220
27221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27222   void * jresult ;
27223   Dali::KeyEvent *arg1 = 0 ;
27224   Dali::KeyEvent *result = 0 ;
27225
27226   arg1 = (Dali::KeyEvent *)jarg1;
27227   if (!arg1) {
27228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27229     return 0;
27230   }
27231   {
27232     try {
27233       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27234     } catch (std::out_of_range& e) {
27235       {
27236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27237       };
27238     } catch (std::exception& e) {
27239       {
27240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27241       };
27242     } catch (...) {
27243       {
27244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27245       };
27246     }
27247   }
27248   jresult = (void *)result;
27249   return jresult;
27250 }
27251
27252
27253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27254   void * jresult ;
27255   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27256   Dali::KeyEvent *arg2 = 0 ;
27257   Dali::KeyEvent *result = 0 ;
27258
27259   arg1 = (Dali::KeyEvent *)jarg1;
27260   arg2 = (Dali::KeyEvent *)jarg2;
27261   if (!arg2) {
27262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27263     return 0;
27264   }
27265   {
27266     try {
27267       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27268     } catch (std::out_of_range& e) {
27269       {
27270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27271       };
27272     } catch (std::exception& e) {
27273       {
27274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27275       };
27276     } catch (...) {
27277       {
27278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27279       };
27280     }
27281   }
27282   jresult = (void *)result;
27283   return jresult;
27284 }
27285
27286
27287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27288   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27289
27290   arg1 = (Dali::KeyEvent *)jarg1;
27291   {
27292     try {
27293       delete arg1;
27294     } catch (std::out_of_range& e) {
27295       {
27296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27297       };
27298     } catch (std::exception& e) {
27299       {
27300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27301       };
27302     } catch (...) {
27303       {
27304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27305       };
27306     }
27307   }
27308 }
27309
27310
27311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27312   unsigned int jresult ;
27313   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27314   bool result;
27315
27316   arg1 = (Dali::KeyEvent *)jarg1;
27317   {
27318     try {
27319       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27320     } catch (std::out_of_range& e) {
27321       {
27322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27323       };
27324     } catch (std::exception& e) {
27325       {
27326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27327       };
27328     } catch (...) {
27329       {
27330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27331       };
27332     }
27333   }
27334   jresult = result;
27335   return jresult;
27336 }
27337
27338
27339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27340   unsigned int jresult ;
27341   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27342   bool result;
27343
27344   arg1 = (Dali::KeyEvent *)jarg1;
27345   {
27346     try {
27347       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27348     } catch (std::out_of_range& e) {
27349       {
27350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27351       };
27352     } catch (std::exception& e) {
27353       {
27354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (...) {
27357       {
27358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27359       };
27360     }
27361   }
27362   jresult = result;
27363   return jresult;
27364 }
27365
27366
27367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27368   unsigned int jresult ;
27369   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27370   bool result;
27371
27372   arg1 = (Dali::KeyEvent *)jarg1;
27373   {
27374     try {
27375       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27376     } catch (std::out_of_range& e) {
27377       {
27378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27379       };
27380     } catch (std::exception& e) {
27381       {
27382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27383       };
27384     } catch (...) {
27385       {
27386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27387       };
27388     }
27389   }
27390   jresult = result;
27391   return jresult;
27392 }
27393
27394
27395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27396   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27397   std::string *arg2 = 0 ;
27398
27399   arg1 = (Dali::KeyEvent *)jarg1;
27400   if (!jarg2) {
27401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27402     return ;
27403   }
27404   std::string arg2_str(jarg2);
27405   arg2 = &arg2_str;
27406   if (arg1) (arg1)->keyPressedName = *arg2;
27407
27408   //argout typemap for const std::string&
27409
27410 }
27411
27412
27413 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27414   char * jresult ;
27415   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27416   std::string *result = 0 ;
27417
27418   arg1 = (Dali::KeyEvent *)jarg1;
27419   result = (std::string *) & ((arg1)->keyPressedName);
27420   jresult = SWIG_csharp_string_callback(result->c_str());
27421   return jresult;
27422 }
27423
27424
27425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27427   std::string *arg2 = 0 ;
27428
27429   arg1 = (Dali::KeyEvent *)jarg1;
27430   if (!jarg2) {
27431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27432     return ;
27433   }
27434   std::string arg2_str(jarg2);
27435   arg2 = &arg2_str;
27436   if (arg1) (arg1)->keyPressed = *arg2;
27437
27438   //argout typemap for const std::string&
27439
27440 }
27441
27442
27443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27444   char * jresult ;
27445   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27446   std::string *result = 0 ;
27447
27448   arg1 = (Dali::KeyEvent *)jarg1;
27449   result = (std::string *) & ((arg1)->keyPressed);
27450   jresult = SWIG_csharp_string_callback(result->c_str());
27451   return jresult;
27452 }
27453
27454
27455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27456   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27457   int arg2 ;
27458
27459   arg1 = (Dali::KeyEvent *)jarg1;
27460   arg2 = (int)jarg2;
27461   if (arg1) (arg1)->keyCode = arg2;
27462 }
27463
27464
27465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27466   int jresult ;
27467   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27468   int result;
27469
27470   arg1 = (Dali::KeyEvent *)jarg1;
27471   result = (int) ((arg1)->keyCode);
27472   jresult = result;
27473   return jresult;
27474 }
27475
27476
27477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27478   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27479   int arg2 ;
27480
27481   arg1 = (Dali::KeyEvent *)jarg1;
27482   arg2 = (int)jarg2;
27483   if (arg1) (arg1)->keyModifier = arg2;
27484 }
27485
27486
27487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27488   int jresult ;
27489   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27490   int result;
27491
27492   arg1 = (Dali::KeyEvent *)jarg1;
27493   result = (int) ((arg1)->keyModifier);
27494   jresult = result;
27495   return jresult;
27496 }
27497
27498
27499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27500   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27501   unsigned long arg2 ;
27502
27503   arg1 = (Dali::KeyEvent *)jarg1;
27504   arg2 = (unsigned long)jarg2;
27505   if (arg1) (arg1)->time = arg2;
27506 }
27507
27508
27509 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27510   unsigned long jresult ;
27511   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27512   unsigned long result;
27513
27514   arg1 = (Dali::KeyEvent *)jarg1;
27515   result = (unsigned long) ((arg1)->time);
27516   jresult = (unsigned long)result;
27517   return jresult;
27518 }
27519
27520
27521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27522   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27523   Dali::KeyEvent::State arg2 ;
27524
27525   arg1 = (Dali::KeyEvent *)jarg1;
27526   arg2 = (Dali::KeyEvent::State)jarg2;
27527   if (arg1) (arg1)->state = arg2;
27528 }
27529
27530
27531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27532   int jresult ;
27533   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27534   Dali::KeyEvent::State result;
27535
27536   arg1 = (Dali::KeyEvent *)jarg1;
27537   result = (Dali::KeyEvent::State) ((arg1)->state);
27538   jresult = (int)result;
27539   return jresult;
27540 }
27541
27542
27543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27544   void * jresult ;
27545   Dali::LongPressGestureDetector *result = 0 ;
27546
27547   {
27548     try {
27549       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27550     } catch (std::out_of_range& e) {
27551       {
27552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27553       };
27554     } catch (std::exception& e) {
27555       {
27556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27557       };
27558     } catch (...) {
27559       {
27560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27561       };
27562     }
27563   }
27564   jresult = (void *)result;
27565   return jresult;
27566 }
27567
27568
27569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27570   void * jresult ;
27571   Dali::LongPressGestureDetector result;
27572
27573   {
27574     try {
27575       result = Dali::LongPressGestureDetector::New();
27576     } catch (std::out_of_range& e) {
27577       {
27578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27579       };
27580     } catch (std::exception& e) {
27581       {
27582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27583       };
27584     } catch (...) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27587       };
27588     }
27589   }
27590   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27591   return jresult;
27592 }
27593
27594
27595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27596   void * jresult ;
27597   unsigned int arg1 ;
27598   Dali::LongPressGestureDetector result;
27599
27600   arg1 = (unsigned int)jarg1;
27601   {
27602     try {
27603       result = Dali::LongPressGestureDetector::New(arg1);
27604     } catch (std::out_of_range& e) {
27605       {
27606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27607       };
27608     } catch (std::exception& e) {
27609       {
27610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27611       };
27612     } catch (...) {
27613       {
27614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27615       };
27616     }
27617   }
27618   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27619   return jresult;
27620 }
27621
27622
27623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27624   void * jresult ;
27625   unsigned int arg1 ;
27626   unsigned int arg2 ;
27627   Dali::LongPressGestureDetector result;
27628
27629   arg1 = (unsigned int)jarg1;
27630   arg2 = (unsigned int)jarg2;
27631   {
27632     try {
27633       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27634     } catch (std::out_of_range& e) {
27635       {
27636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27637       };
27638     } catch (std::exception& e) {
27639       {
27640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27645       };
27646     }
27647   }
27648   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27654   void * jresult ;
27655   Dali::BaseHandle arg1 ;
27656   Dali::BaseHandle *argp1 ;
27657   Dali::LongPressGestureDetector result;
27658
27659   argp1 = (Dali::BaseHandle *)jarg1;
27660   if (!argp1) {
27661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27662     return 0;
27663   }
27664   arg1 = *argp1;
27665   {
27666     try {
27667       result = Dali::LongPressGestureDetector::DownCast(arg1);
27668     } catch (std::out_of_range& e) {
27669       {
27670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27671       };
27672     } catch (std::exception& e) {
27673       {
27674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (...) {
27677       {
27678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27679       };
27680     }
27681   }
27682   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27683   return jresult;
27684 }
27685
27686
27687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27688   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27689
27690   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27691   {
27692     try {
27693       delete arg1;
27694     } catch (std::out_of_range& e) {
27695       {
27696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27697       };
27698     } catch (std::exception& e) {
27699       {
27700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27701       };
27702     } catch (...) {
27703       {
27704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27705       };
27706     }
27707   }
27708 }
27709
27710
27711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27712   void * jresult ;
27713   Dali::LongPressGestureDetector *arg1 = 0 ;
27714   Dali::LongPressGestureDetector *result = 0 ;
27715
27716   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27717   if (!arg1) {
27718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27719     return 0;
27720   }
27721   {
27722     try {
27723       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27724     } catch (std::out_of_range& e) {
27725       {
27726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27727       };
27728     } catch (std::exception& e) {
27729       {
27730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27731       };
27732     } catch (...) {
27733       {
27734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27735       };
27736     }
27737   }
27738   jresult = (void *)result;
27739   return jresult;
27740 }
27741
27742
27743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27744   void * jresult ;
27745   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27746   Dali::LongPressGestureDetector *arg2 = 0 ;
27747   Dali::LongPressGestureDetector *result = 0 ;
27748
27749   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27750   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27751   if (!arg2) {
27752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27753     return 0;
27754   }
27755   {
27756     try {
27757       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27758     } catch (std::out_of_range& e) {
27759       {
27760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27761       };
27762     } catch (std::exception& e) {
27763       {
27764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27765       };
27766     } catch (...) {
27767       {
27768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27769       };
27770     }
27771   }
27772   jresult = (void *)result;
27773   return jresult;
27774 }
27775
27776
27777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27778   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27779   unsigned int arg2 ;
27780
27781   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27782   arg2 = (unsigned int)jarg2;
27783   {
27784     try {
27785       (arg1)->SetTouchesRequired(arg2);
27786     } catch (std::out_of_range& e) {
27787       {
27788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27789       };
27790     } catch (std::exception& e) {
27791       {
27792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27793       };
27794     } catch (...) {
27795       {
27796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27797       };
27798     }
27799   }
27800 }
27801
27802
27803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27804   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27805   unsigned int arg2 ;
27806   unsigned int arg3 ;
27807
27808   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27809   arg2 = (unsigned int)jarg2;
27810   arg3 = (unsigned int)jarg3;
27811   {
27812     try {
27813       (arg1)->SetTouchesRequired(arg2,arg3);
27814     } catch (std::out_of_range& e) {
27815       {
27816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27817       };
27818     } catch (std::exception& e) {
27819       {
27820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27821       };
27822     } catch (...) {
27823       {
27824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27825       };
27826     }
27827   }
27828 }
27829
27830
27831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27832   unsigned int jresult ;
27833   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27834   unsigned int result;
27835
27836   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27837   {
27838     try {
27839       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27840     } catch (std::out_of_range& e) {
27841       {
27842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (std::exception& e) {
27845       {
27846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27847       };
27848     } catch (...) {
27849       {
27850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27851       };
27852     }
27853   }
27854   jresult = result;
27855   return jresult;
27856 }
27857
27858
27859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27860   unsigned int jresult ;
27861   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27862   unsigned int result;
27863
27864   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27865   {
27866     try {
27867       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27868     } catch (std::out_of_range& e) {
27869       {
27870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27871       };
27872     } catch (std::exception& e) {
27873       {
27874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27875       };
27876     } catch (...) {
27877       {
27878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27879       };
27880     }
27881   }
27882   jresult = result;
27883   return jresult;
27884 }
27885
27886
27887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27888   void * jresult ;
27889   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27890   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27891
27892   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27893   {
27894     try {
27895       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27896     } catch (std::out_of_range& e) {
27897       {
27898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27899       };
27900     } catch (std::exception& e) {
27901       {
27902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27903       };
27904     } catch (...) {
27905       {
27906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27907       };
27908     }
27909   }
27910   jresult = (void *)result;
27911   return jresult;
27912 }
27913
27914
27915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27916   void * jresult ;
27917   Dali::Gesture::State arg1 ;
27918   Dali::LongPressGesture *result = 0 ;
27919
27920   arg1 = (Dali::Gesture::State)jarg1;
27921   {
27922     try {
27923       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27924     } catch (std::out_of_range& e) {
27925       {
27926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (std::exception& e) {
27929       {
27930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27931       };
27932     } catch (...) {
27933       {
27934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27935       };
27936     }
27937   }
27938   jresult = (void *)result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27944   void * jresult ;
27945   Dali::LongPressGesture *arg1 = 0 ;
27946   Dali::LongPressGesture *result = 0 ;
27947
27948   arg1 = (Dali::LongPressGesture *)jarg1;
27949   if (!arg1) {
27950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27951     return 0;
27952   }
27953   {
27954     try {
27955       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27956     } catch (std::out_of_range& e) {
27957       {
27958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (std::exception& e) {
27961       {
27962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27963       };
27964     } catch (...) {
27965       {
27966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27967       };
27968     }
27969   }
27970   jresult = (void *)result;
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27976   void * jresult ;
27977   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27978   Dali::LongPressGesture *arg2 = 0 ;
27979   Dali::LongPressGesture *result = 0 ;
27980
27981   arg1 = (Dali::LongPressGesture *)jarg1;
27982   arg2 = (Dali::LongPressGesture *)jarg2;
27983   if (!arg2) {
27984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27985     return 0;
27986   }
27987   {
27988     try {
27989       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27990     } catch (std::out_of_range& e) {
27991       {
27992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27993       };
27994     } catch (std::exception& e) {
27995       {
27996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27997       };
27998     } catch (...) {
27999       {
28000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28001       };
28002     }
28003   }
28004   jresult = (void *)result;
28005   return jresult;
28006 }
28007
28008
28009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28010   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28011
28012   arg1 = (Dali::LongPressGesture *)jarg1;
28013   {
28014     try {
28015       delete arg1;
28016     } catch (std::out_of_range& e) {
28017       {
28018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28019       };
28020     } catch (std::exception& e) {
28021       {
28022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28023       };
28024     } catch (...) {
28025       {
28026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28027       };
28028     }
28029   }
28030 }
28031
28032
28033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28034   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28035   unsigned int arg2 ;
28036
28037   arg1 = (Dali::LongPressGesture *)jarg1;
28038   arg2 = (unsigned int)jarg2;
28039   if (arg1) (arg1)->numberOfTouches = arg2;
28040 }
28041
28042
28043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28044   unsigned int jresult ;
28045   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28046   unsigned int result;
28047
28048   arg1 = (Dali::LongPressGesture *)jarg1;
28049   result = (unsigned int) ((arg1)->numberOfTouches);
28050   jresult = result;
28051   return jresult;
28052 }
28053
28054
28055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28056   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28057   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28058
28059   arg1 = (Dali::LongPressGesture *)jarg1;
28060   arg2 = (Dali::Vector2 *)jarg2;
28061   if (arg1) (arg1)->screenPoint = *arg2;
28062 }
28063
28064
28065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28066   void * jresult ;
28067   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28068   Dali::Vector2 *result = 0 ;
28069
28070   arg1 = (Dali::LongPressGesture *)jarg1;
28071   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28072   jresult = (void *)result;
28073   return jresult;
28074 }
28075
28076
28077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28078   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28079   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28080
28081   arg1 = (Dali::LongPressGesture *)jarg1;
28082   arg2 = (Dali::Vector2 *)jarg2;
28083   if (arg1) (arg1)->localPoint = *arg2;
28084 }
28085
28086
28087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28088   void * jresult ;
28089   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28090   Dali::Vector2 *result = 0 ;
28091
28092   arg1 = (Dali::LongPressGesture *)jarg1;
28093   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28094   jresult = (void *)result;
28095   return jresult;
28096 }
28097
28098
28099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28100   void * jresult ;
28101   Dali::WheelEvent *result = 0 ;
28102
28103   {
28104     try {
28105       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28106     } catch (std::out_of_range& e) {
28107       {
28108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28109       };
28110     } catch (std::exception& e) {
28111       {
28112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28113       };
28114     } catch (...) {
28115       {
28116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28117       };
28118     }
28119   }
28120   jresult = (void *)result;
28121   return jresult;
28122 }
28123
28124
28125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28126   void * jresult ;
28127   Dali::WheelEvent::Type arg1 ;
28128   int arg2 ;
28129   unsigned int arg3 ;
28130   Dali::Vector2 arg4 ;
28131   int arg5 ;
28132   unsigned int arg6 ;
28133   Dali::Vector2 *argp4 ;
28134   Dali::WheelEvent *result = 0 ;
28135
28136   arg1 = (Dali::WheelEvent::Type)jarg1;
28137   arg2 = (int)jarg2;
28138   arg3 = (unsigned int)jarg3;
28139   argp4 = (Dali::Vector2 *)jarg4;
28140   if (!argp4) {
28141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28142     return 0;
28143   }
28144   arg4 = *argp4;
28145   arg5 = (int)jarg5;
28146   arg6 = (unsigned int)jarg6;
28147   {
28148     try {
28149       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28150     } catch (std::out_of_range& e) {
28151       {
28152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28153       };
28154     } catch (std::exception& e) {
28155       {
28156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28157       };
28158     } catch (...) {
28159       {
28160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28161       };
28162     }
28163   }
28164   jresult = (void *)result;
28165   return jresult;
28166 }
28167
28168
28169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28170   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28171
28172   arg1 = (Dali::WheelEvent *)jarg1;
28173   {
28174     try {
28175       delete arg1;
28176     } catch (std::out_of_range& e) {
28177       {
28178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28179       };
28180     } catch (std::exception& e) {
28181       {
28182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28183       };
28184     } catch (...) {
28185       {
28186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28187       };
28188     }
28189   }
28190 }
28191
28192
28193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28194   unsigned int jresult ;
28195   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28196   bool result;
28197
28198   arg1 = (Dali::WheelEvent *)jarg1;
28199   {
28200     try {
28201       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28202     } catch (std::out_of_range& e) {
28203       {
28204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28205       };
28206     } catch (std::exception& e) {
28207       {
28208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28209       };
28210     } catch (...) {
28211       {
28212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28213       };
28214     }
28215   }
28216   jresult = result;
28217   return jresult;
28218 }
28219
28220
28221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28222   unsigned int jresult ;
28223   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28224   bool result;
28225
28226   arg1 = (Dali::WheelEvent *)jarg1;
28227   {
28228     try {
28229       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28230     } catch (std::out_of_range& e) {
28231       {
28232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28233       };
28234     } catch (std::exception& e) {
28235       {
28236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28237       };
28238     } catch (...) {
28239       {
28240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28241       };
28242     }
28243   }
28244   jresult = result;
28245   return jresult;
28246 }
28247
28248
28249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28250   unsigned int jresult ;
28251   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28252   bool result;
28253
28254   arg1 = (Dali::WheelEvent *)jarg1;
28255   {
28256     try {
28257       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28258     } catch (std::out_of_range& e) {
28259       {
28260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28261       };
28262     } catch (std::exception& e) {
28263       {
28264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28265       };
28266     } catch (...) {
28267       {
28268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28269       };
28270     }
28271   }
28272   jresult = result;
28273   return jresult;
28274 }
28275
28276
28277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28278   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28279   Dali::WheelEvent::Type arg2 ;
28280
28281   arg1 = (Dali::WheelEvent *)jarg1;
28282   arg2 = (Dali::WheelEvent::Type)jarg2;
28283   if (arg1) (arg1)->type = arg2;
28284 }
28285
28286
28287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28288   int jresult ;
28289   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28290   Dali::WheelEvent::Type result;
28291
28292   arg1 = (Dali::WheelEvent *)jarg1;
28293   result = (Dali::WheelEvent::Type) ((arg1)->type);
28294   jresult = (int)result;
28295   return jresult;
28296 }
28297
28298
28299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28300   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28301   int arg2 ;
28302
28303   arg1 = (Dali::WheelEvent *)jarg1;
28304   arg2 = (int)jarg2;
28305   if (arg1) (arg1)->direction = arg2;
28306 }
28307
28308
28309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28310   int jresult ;
28311   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28312   int result;
28313
28314   arg1 = (Dali::WheelEvent *)jarg1;
28315   result = (int) ((arg1)->direction);
28316   jresult = result;
28317   return jresult;
28318 }
28319
28320
28321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28322   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28323   unsigned int arg2 ;
28324
28325   arg1 = (Dali::WheelEvent *)jarg1;
28326   arg2 = (unsigned int)jarg2;
28327   if (arg1) (arg1)->modifiers = arg2;
28328 }
28329
28330
28331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28332   unsigned int jresult ;
28333   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28334   unsigned int result;
28335
28336   arg1 = (Dali::WheelEvent *)jarg1;
28337   result = (unsigned int) ((arg1)->modifiers);
28338   jresult = result;
28339   return jresult;
28340 }
28341
28342
28343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28344   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28345   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28346
28347   arg1 = (Dali::WheelEvent *)jarg1;
28348   arg2 = (Dali::Vector2 *)jarg2;
28349   if (arg1) (arg1)->point = *arg2;
28350 }
28351
28352
28353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28354   void * jresult ;
28355   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28356   Dali::Vector2 *result = 0 ;
28357
28358   arg1 = (Dali::WheelEvent *)jarg1;
28359   result = (Dali::Vector2 *)& ((arg1)->point);
28360   jresult = (void *)result;
28361   return jresult;
28362 }
28363
28364
28365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28366   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28367   int arg2 ;
28368
28369   arg1 = (Dali::WheelEvent *)jarg1;
28370   arg2 = (int)jarg2;
28371   if (arg1) (arg1)->z = arg2;
28372 }
28373
28374
28375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28376   int jresult ;
28377   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28378   int result;
28379
28380   arg1 = (Dali::WheelEvent *)jarg1;
28381   result = (int) ((arg1)->z);
28382   jresult = result;
28383   return jresult;
28384 }
28385
28386
28387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28388   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28389   unsigned int arg2 ;
28390
28391   arg1 = (Dali::WheelEvent *)jarg1;
28392   arg2 = (unsigned int)jarg2;
28393   if (arg1) (arg1)->timeStamp = arg2;
28394 }
28395
28396
28397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28398   unsigned int jresult ;
28399   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28400   unsigned int result;
28401
28402   arg1 = (Dali::WheelEvent *)jarg1;
28403   result = (unsigned int) ((arg1)->timeStamp);
28404   jresult = result;
28405   return jresult;
28406 }
28407
28408 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28409   char * jresult ;
28410   Dali::KeyEvent *arg1 = 0 ;
28411   std::string result;
28412
28413   arg1 = (Dali::KeyEvent *)jarg1;
28414   if (!arg1) {
28415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28416     return 0;
28417   }
28418   {
28419     try {
28420       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28421     } catch (std::out_of_range& e) {
28422       {
28423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28424       };
28425     } catch (std::exception& e) {
28426       {
28427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28428       };
28429     } catch (...) {
28430       {
28431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28432       };
28433     }
28434   }
28435   jresult = SWIG_csharp_string_callback((&result)->c_str());
28436   return jresult;
28437 }
28438
28439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28440   int jresult ;
28441   Dali::KeyEvent *arg1 = 0 ;
28442   Dali::DevelDevice::Class::Type result;
28443
28444   arg1 = (Dali::KeyEvent *)jarg1;
28445   if (!arg1) {
28446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28447     return 0;
28448   }
28449   {
28450     try {
28451       result = (Dali::DevelDevice::Class::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28452     } catch (std::out_of_range& e) {
28453       {
28454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28455       };
28456     } catch (std::exception& e) {
28457       {
28458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28459       };
28460     } catch (...) {
28461       {
28462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28463       };
28464     }
28465   }
28466   jresult = (int)result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28472   Dali::Actor arg1 ;
28473   Dali::Actor *argp1 ;
28474
28475   argp1 = (Dali::Actor *)jarg1;
28476   if (!argp1) {
28477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28478     return ;
28479   }
28480   arg1 = *argp1;
28481   {
28482     try {
28483       Dali::DevelActor::Raise(arg1);
28484     } catch (std::out_of_range& e) {
28485       {
28486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28487       };
28488     } catch (std::exception& e) {
28489       {
28490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28491       };
28492     } catch (...) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28495       };
28496     }
28497   }
28498 }
28499
28500
28501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28502   Dali::Actor arg1 ;
28503   Dali::Actor *argp1 ;
28504
28505   argp1 = (Dali::Actor *)jarg1;
28506   if (!argp1) {
28507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28508     return ;
28509   }
28510   arg1 = *argp1;
28511   {
28512     try {
28513       Dali::DevelActor::Lower(arg1);
28514     } catch (std::out_of_range& e) {
28515       {
28516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28517       };
28518     } catch (std::exception& e) {
28519       {
28520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28521       };
28522     } catch (...) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28525       };
28526     }
28527   }
28528 }
28529
28530
28531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28532   Dali::Actor arg1 ;
28533   Dali::Actor *argp1 ;
28534
28535   argp1 = (Dali::Actor *)jarg1;
28536   if (!argp1) {
28537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28538     return ;
28539   }
28540   arg1 = *argp1;
28541   {
28542     try {
28543       Dali::DevelActor::RaiseToTop(arg1);
28544     } catch (std::out_of_range& e) {
28545       {
28546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28547       };
28548     } catch (std::exception& e) {
28549       {
28550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28551       };
28552     } catch (...) {
28553       {
28554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28555       };
28556     }
28557   }
28558 }
28559
28560
28561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28562   Dali::Actor arg1 ;
28563   Dali::Actor *argp1 ;
28564
28565   argp1 = (Dali::Actor *)jarg1;
28566   if (!argp1) {
28567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28568     return ;
28569   }
28570   arg1 = *argp1;
28571   {
28572     try {
28573       Dali::DevelActor::LowerToBottom(arg1);
28574     } catch (std::out_of_range& e) {
28575       {
28576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28577       };
28578     } catch (std::exception& e) {
28579       {
28580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28581       };
28582     } catch (...) {
28583       {
28584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28585       };
28586     }
28587   }
28588 }
28589
28590
28591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28592   Dali::Actor arg1 ;
28593   Dali::Actor arg2 ;
28594   Dali::Actor *argp1 ;
28595   Dali::Actor *argp2 ;
28596
28597   argp1 = (Dali::Actor *)jarg1;
28598   if (!argp1) {
28599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28600     return ;
28601   }
28602   arg1 = *argp1;
28603   argp2 = (Dali::Actor *)jarg2;
28604   if (!argp2) {
28605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28606     return ;
28607   }
28608   arg2 = *argp2;
28609   {
28610     try {
28611       Dali::DevelActor::RaiseAbove(arg1,arg2);
28612     } catch (std::out_of_range& e) {
28613       {
28614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28615       };
28616     } catch (std::exception& e) {
28617       {
28618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28619       };
28620     } catch (...) {
28621       {
28622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28623       };
28624     }
28625   }
28626 }
28627
28628
28629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28630   Dali::Actor arg1 ;
28631   Dali::Actor arg2 ;
28632   Dali::Actor *argp1 ;
28633   Dali::Actor *argp2 ;
28634
28635   argp1 = (Dali::Actor *)jarg1;
28636   if (!argp1) {
28637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28638     return ;
28639   }
28640   arg1 = *argp1;
28641   argp2 = (Dali::Actor *)jarg2;
28642   if (!argp2) {
28643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28644     return ;
28645   }
28646   arg2 = *argp2;
28647   {
28648     try {
28649       Dali::DevelActor::LowerBelow(arg1,arg2);
28650     } catch (std::out_of_range& e) {
28651       {
28652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28653       };
28654     } catch (std::exception& e) {
28655       {
28656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28657       };
28658     } catch (...) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28661       };
28662     }
28663   }
28664 }
28665
28666
28667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28668   void * jresult ;
28669   Dali::Actor arg1 ;
28670   Dali::Actor *argp1 ;
28671   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28672
28673   argp1 = (Dali::Actor *)jarg1;
28674   if (!argp1) {
28675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28676     return 0;
28677   }
28678   arg1 = *argp1;
28679   {
28680     try {
28681       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28682     } catch (std::out_of_range& e) {
28683       {
28684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28685       };
28686     } catch (std::exception& e) {
28687       {
28688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28689       };
28690     } catch (...) {
28691       {
28692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28693       };
28694     }
28695   }
28696   jresult = (void *)result;
28697   return jresult;
28698 }
28699
28700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28701   int jresult ;
28702   int result;
28703
28704   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28705   jresult = (int)result;
28706   return jresult;
28707 }
28708
28709
28710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28711   int jresult ;
28712   int result;
28713
28714   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28715   jresult = (int)result;
28716   return jresult;
28717 }
28718
28719
28720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28721   int jresult ;
28722   int result;
28723
28724   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28725   jresult = (int)result;
28726   return jresult;
28727 }
28728
28729
28730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28731   int jresult ;
28732   int result;
28733
28734   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28735   jresult = (int)result;
28736   return jresult;
28737 }
28738
28739
28740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28741   int jresult ;
28742   int result;
28743
28744   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28745   jresult = (int)result;
28746   return jresult;
28747 }
28748
28749
28750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28751   int jresult ;
28752   int result;
28753
28754   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28755   jresult = (int)result;
28756   return jresult;
28757 }
28758
28759
28760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28761   int jresult ;
28762   int result;
28763
28764   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28765   jresult = (int)result;
28766   return jresult;
28767 }
28768
28769
28770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28771   int jresult ;
28772   int result;
28773
28774   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28775   jresult = (int)result;
28776   return jresult;
28777 }
28778
28779
28780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28781   int jresult ;
28782   int result;
28783
28784   result = (int)Dali::Actor::Property::SIZE;
28785   jresult = (int)result;
28786   return jresult;
28787 }
28788
28789
28790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28791   int jresult ;
28792   int result;
28793
28794   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28795   jresult = (int)result;
28796   return jresult;
28797 }
28798
28799
28800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28801   int jresult ;
28802   int result;
28803
28804   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28805   jresult = (int)result;
28806   return jresult;
28807 }
28808
28809
28810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28811   int jresult ;
28812   int result;
28813
28814   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28815   jresult = (int)result;
28816   return jresult;
28817 }
28818
28819
28820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28821   int jresult ;
28822   int result;
28823
28824   result = (int)Dali::Actor::Property::POSITION;
28825   jresult = (int)result;
28826   return jresult;
28827 }
28828
28829
28830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28831   int jresult ;
28832   int result;
28833
28834   result = (int)Dali::Actor::Property::POSITION_X;
28835   jresult = (int)result;
28836   return jresult;
28837 }
28838
28839
28840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28841   int jresult ;
28842   int result;
28843
28844   result = (int)Dali::Actor::Property::POSITION_Y;
28845   jresult = (int)result;
28846   return jresult;
28847 }
28848
28849
28850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28851   int jresult ;
28852   int result;
28853
28854   result = (int)Dali::Actor::Property::POSITION_Z;
28855   jresult = (int)result;
28856   return jresult;
28857 }
28858
28859
28860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28861   int jresult ;
28862   int result;
28863
28864   result = (int)Dali::Actor::Property::WORLD_POSITION;
28865   jresult = (int)result;
28866   return jresult;
28867 }
28868
28869
28870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28871   int jresult ;
28872   int result;
28873
28874   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28875   jresult = (int)result;
28876   return jresult;
28877 }
28878
28879
28880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28881   int jresult ;
28882   int result;
28883
28884   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28885   jresult = (int)result;
28886   return jresult;
28887 }
28888
28889
28890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28891   int jresult ;
28892   int result;
28893
28894   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28895   jresult = (int)result;
28896   return jresult;
28897 }
28898
28899
28900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28901   int jresult ;
28902   int result;
28903
28904   result = (int)Dali::Actor::Property::ORIENTATION;
28905   jresult = (int)result;
28906   return jresult;
28907 }
28908
28909
28910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28911   int jresult ;
28912   int result;
28913
28914   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28915   jresult = (int)result;
28916   return jresult;
28917 }
28918
28919
28920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28921   int jresult ;
28922   int result;
28923
28924   result = (int)Dali::Actor::Property::SCALE;
28925   jresult = (int)result;
28926   return jresult;
28927 }
28928
28929
28930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28931   int jresult ;
28932   int result;
28933
28934   result = (int)Dali::Actor::Property::SCALE_X;
28935   jresult = (int)result;
28936   return jresult;
28937 }
28938
28939
28940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28941   int jresult ;
28942   int result;
28943
28944   result = (int)Dali::Actor::Property::SCALE_Y;
28945   jresult = (int)result;
28946   return jresult;
28947 }
28948
28949
28950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28951   int jresult ;
28952   int result;
28953
28954   result = (int)Dali::Actor::Property::SCALE_Z;
28955   jresult = (int)result;
28956   return jresult;
28957 }
28958
28959
28960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28961   int jresult ;
28962   int result;
28963
28964   result = (int)Dali::Actor::Property::WORLD_SCALE;
28965   jresult = (int)result;
28966   return jresult;
28967 }
28968
28969
28970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28971   int jresult ;
28972   int result;
28973
28974   result = (int)Dali::Actor::Property::VISIBLE;
28975   jresult = (int)result;
28976   return jresult;
28977 }
28978
28979
28980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28981   int jresult ;
28982   int result;
28983
28984   result = (int)Dali::Actor::Property::COLOR;
28985   jresult = (int)result;
28986   return jresult;
28987 }
28988
28989
28990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28991   int jresult ;
28992   int result;
28993
28994   result = (int)Dali::Actor::Property::COLOR_RED;
28995   jresult = (int)result;
28996   return jresult;
28997 }
28998
28999
29000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29001   int jresult ;
29002   int result;
29003
29004   result = (int)Dali::Actor::Property::COLOR_GREEN;
29005   jresult = (int)result;
29006   return jresult;
29007 }
29008
29009
29010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29011   int jresult ;
29012   int result;
29013
29014   result = (int)Dali::Actor::Property::COLOR_BLUE;
29015   jresult = (int)result;
29016   return jresult;
29017 }
29018
29019
29020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29021   int jresult ;
29022   int result;
29023
29024   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29025   jresult = (int)result;
29026   return jresult;
29027 }
29028
29029
29030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29031   int jresult ;
29032   int result;
29033
29034   result = (int)Dali::Actor::Property::WORLD_COLOR;
29035   jresult = (int)result;
29036   return jresult;
29037 }
29038
29039
29040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29041   int jresult ;
29042   int result;
29043
29044   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29045   jresult = (int)result;
29046   return jresult;
29047 }
29048
29049
29050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29051   int jresult ;
29052   int result;
29053
29054   result = (int)Dali::Actor::Property::NAME;
29055   jresult = (int)result;
29056   return jresult;
29057 }
29058
29059
29060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29061   int jresult ;
29062   int result;
29063
29064   result = (int)Dali::Actor::Property::SENSITIVE;
29065   jresult = (int)result;
29066   return jresult;
29067 }
29068
29069
29070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29071   int jresult ;
29072   int result;
29073
29074   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29075   jresult = (int)result;
29076   return jresult;
29077 }
29078
29079
29080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29081   int jresult ;
29082   int result;
29083
29084   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29085   jresult = (int)result;
29086   return jresult;
29087 }
29088
29089
29090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29091   int jresult ;
29092   int result;
29093
29094   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29095   jresult = (int)result;
29096   return jresult;
29097 }
29098
29099
29100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29101   int jresult ;
29102   int result;
29103
29104   result = (int)Dali::Actor::Property::COLOR_MODE;
29105   jresult = (int)result;
29106   return jresult;
29107 }
29108
29109
29110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29111   int jresult ;
29112   int result;
29113
29114   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29115   jresult = (int)result;
29116   return jresult;
29117 }
29118
29119
29120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29121   int jresult ;
29122   int result;
29123
29124   result = (int)Dali::Actor::Property::DRAW_MODE;
29125   jresult = (int)result;
29126   return jresult;
29127 }
29128
29129
29130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29131   int jresult ;
29132   int result;
29133
29134   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29135   jresult = (int)result;
29136   return jresult;
29137 }
29138
29139
29140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29141   int jresult ;
29142   int result;
29143
29144   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29145   jresult = (int)result;
29146   return jresult;
29147 }
29148
29149
29150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29151   int jresult ;
29152   int result;
29153
29154   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29155   jresult = (int)result;
29156   return jresult;
29157 }
29158
29159
29160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29161   int jresult ;
29162   int result;
29163
29164   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29165   jresult = (int)result;
29166   return jresult;
29167 }
29168
29169
29170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29171   int jresult ;
29172   int result;
29173
29174   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29175   jresult = (int)result;
29176   return jresult;
29177 }
29178
29179
29180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29181   int jresult ;
29182   int result;
29183
29184   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29185   jresult = (int)result;
29186   return jresult;
29187 }
29188
29189
29190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29191   int jresult ;
29192   int result;
29193
29194   result = (int)Dali::Actor::Property::PADDING;
29195   jresult = (int)result;
29196   return jresult;
29197 }
29198
29199
29200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29201   int jresult ;
29202   int result;
29203
29204   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29205   jresult = (int)result;
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29211   int jresult ;
29212   int result;
29213
29214   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29215   jresult = (int)result;
29216   return jresult;
29217 }
29218
29219
29220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29221   int jresult ;
29222   int result;
29223
29224   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29225   jresult = (int)result;
29226   return jresult;
29227 }
29228
29229
29230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29231   int jresult ;
29232   int result;
29233
29234   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29235   jresult = (int)result;
29236   return jresult;
29237 }
29238
29239
29240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29241   void * jresult ;
29242   Dali::Actor::Property *result = 0 ;
29243
29244   {
29245     try {
29246       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29247     } catch (std::out_of_range& e) {
29248       {
29249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29250       };
29251     } catch (std::exception& e) {
29252       {
29253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29254       };
29255     } catch (...) {
29256       {
29257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29258       };
29259     }
29260   }
29261   jresult = (void *)result;
29262   return jresult;
29263 }
29264
29265
29266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29267   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29268
29269   arg1 = (Dali::Actor::Property *)jarg1;
29270   {
29271     try {
29272       delete arg1;
29273     } catch (std::out_of_range& e) {
29274       {
29275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29276       };
29277     } catch (std::exception& e) {
29278       {
29279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29280       };
29281     } catch (...) {
29282       {
29283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29284       };
29285     }
29286   }
29287 }
29288
29289
29290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29291   void * jresult ;
29292   Dali::Actor *result = 0 ;
29293
29294   {
29295     try {
29296       result = (Dali::Actor *)new Dali::Actor();
29297     } catch (std::out_of_range& e) {
29298       {
29299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29300       };
29301     } catch (std::exception& e) {
29302       {
29303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29308       };
29309     }
29310   }
29311   jresult = (void *)result;
29312   return jresult;
29313 }
29314
29315
29316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29317   void * jresult ;
29318   Dali::Actor result;
29319
29320   {
29321     try {
29322       result = Dali::Actor::New();
29323     } catch (std::out_of_range& e) {
29324       {
29325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29326       };
29327     } catch (std::exception& e) {
29328       {
29329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29330       };
29331     } catch (...) {
29332       {
29333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29334       };
29335     }
29336   }
29337   jresult = new Dali::Actor((const Dali::Actor &)result);
29338   return jresult;
29339 }
29340
29341
29342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29343   void * jresult ;
29344   Dali::BaseHandle arg1 ;
29345   Dali::BaseHandle *argp1 ;
29346   Dali::Actor result;
29347
29348   argp1 = (Dali::BaseHandle *)jarg1;
29349   if (!argp1) {
29350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29351     return 0;
29352   }
29353   arg1 = *argp1;
29354   {
29355     try {
29356       result = Dali::Actor::DownCast(arg1);
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::Actor((const Dali::Actor &)result);
29372   return jresult;
29373 }
29374
29375
29376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29378
29379   arg1 = (Dali::Actor *)jarg1;
29380   {
29381     try {
29382       delete arg1;
29383     } catch (std::out_of_range& e) {
29384       {
29385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29386       };
29387     } catch (std::exception& e) {
29388       {
29389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29390       };
29391     } catch (...) {
29392       {
29393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29394       };
29395     }
29396   }
29397 }
29398
29399
29400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29401   void * jresult ;
29402   Dali::Actor *arg1 = 0 ;
29403   Dali::Actor *result = 0 ;
29404
29405   arg1 = (Dali::Actor *)jarg1;
29406   if (!arg1) {
29407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29408     return 0;
29409   }
29410   {
29411     try {
29412       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29413     } catch (std::out_of_range& e) {
29414       {
29415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29416       };
29417     } catch (std::exception& e) {
29418       {
29419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (...) {
29422       {
29423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29424       };
29425     }
29426   }
29427   jresult = (void *)result;
29428   return jresult;
29429 }
29430
29431
29432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29433   void * jresult ;
29434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29435   Dali::Actor *arg2 = 0 ;
29436   Dali::Actor *result = 0 ;
29437
29438   arg1 = (Dali::Actor *)jarg1;
29439   arg2 = (Dali::Actor *)jarg2;
29440   if (!arg2) {
29441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29442     return 0;
29443   }
29444   {
29445     try {
29446       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29447     } catch (std::out_of_range& e) {
29448       {
29449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29450       };
29451     } catch (std::exception& e) {
29452       {
29453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29454       };
29455     } catch (...) {
29456       {
29457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29458       };
29459     }
29460   }
29461   jresult = (void *)result;
29462   return jresult;
29463 }
29464
29465
29466 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29467   char * jresult ;
29468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29469   std::string *result = 0 ;
29470
29471   arg1 = (Dali::Actor *)jarg1;
29472   {
29473     try {
29474       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29475     } catch (std::out_of_range& e) {
29476       {
29477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29478       };
29479     } catch (std::exception& e) {
29480       {
29481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29482       };
29483     } catch (...) {
29484       {
29485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29486       };
29487     }
29488   }
29489   jresult = SWIG_csharp_string_callback(result->c_str());
29490   return jresult;
29491 }
29492
29493
29494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29496   std::string *arg2 = 0 ;
29497
29498   arg1 = (Dali::Actor *)jarg1;
29499   if (!jarg2) {
29500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29501     return ;
29502   }
29503   std::string arg2_str(jarg2);
29504   arg2 = &arg2_str;
29505   {
29506     try {
29507       (arg1)->SetName((std::string const &)*arg2);
29508     } catch (std::out_of_range& e) {
29509       {
29510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29511       };
29512     } catch (std::exception& e) {
29513       {
29514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29515       };
29516     } catch (...) {
29517       {
29518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29519       };
29520     }
29521   }
29522
29523   //argout typemap for const std::string&
29524
29525 }
29526
29527
29528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29529   unsigned int jresult ;
29530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29531   unsigned int result;
29532
29533   arg1 = (Dali::Actor *)jarg1;
29534   {
29535     try {
29536       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29537     } catch (std::out_of_range& e) {
29538       {
29539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29540       };
29541     } catch (std::exception& e) {
29542       {
29543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29544       };
29545     } catch (...) {
29546       {
29547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29548       };
29549     }
29550   }
29551   jresult = result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29557   unsigned int jresult ;
29558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29559   bool result;
29560
29561   arg1 = (Dali::Actor *)jarg1;
29562   {
29563     try {
29564       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29565     } catch (std::out_of_range& e) {
29566       {
29567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29568       };
29569     } catch (std::exception& e) {
29570       {
29571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29572       };
29573     } catch (...) {
29574       {
29575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29576       };
29577     }
29578   }
29579   jresult = result;
29580   return jresult;
29581 }
29582
29583
29584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29585   unsigned int jresult ;
29586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29587   bool result;
29588
29589   arg1 = (Dali::Actor *)jarg1;
29590   {
29591     try {
29592       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29593     } catch (std::out_of_range& e) {
29594       {
29595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29596       };
29597     } catch (std::exception& e) {
29598       {
29599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29600       };
29601     } catch (...) {
29602       {
29603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29604       };
29605     }
29606   }
29607   jresult = result;
29608   return jresult;
29609 }
29610
29611
29612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29613   unsigned int jresult ;
29614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29615   bool result;
29616
29617   arg1 = (Dali::Actor *)jarg1;
29618   {
29619     try {
29620       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29621     } catch (std::out_of_range& e) {
29622       {
29623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29624       };
29625     } catch (std::exception& e) {
29626       {
29627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29628       };
29629     } catch (...) {
29630       {
29631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29632       };
29633     }
29634   }
29635   jresult = result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29641   void * jresult ;
29642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29643   Dali::Layer result;
29644
29645   arg1 = (Dali::Actor *)jarg1;
29646   {
29647     try {
29648       result = (arg1)->GetLayer();
29649     } catch (std::out_of_range& e) {
29650       {
29651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29652       };
29653     } catch (std::exception& e) {
29654       {
29655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29656       };
29657     } catch (...) {
29658       {
29659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29660       };
29661     }
29662   }
29663   jresult = new Dali::Layer((const Dali::Layer &)result);
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29670   Dali::Actor arg2 ;
29671   Dali::Actor *argp2 ;
29672
29673   arg1 = (Dali::Actor *)jarg1;
29674   argp2 = (Dali::Actor *)jarg2;
29675   if (!argp2) {
29676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29677     return ;
29678   }
29679   arg2 = *argp2;
29680   {
29681     try {
29682       (arg1)->Add(arg2);
29683     } catch (std::out_of_range& e) {
29684       {
29685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29686       };
29687     } catch (std::exception& e) {
29688       {
29689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29690       };
29691     } catch (...) {
29692       {
29693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29694       };
29695     }
29696   }
29697 }
29698
29699
29700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29702   Dali::Actor arg2 ;
29703   Dali::Actor *argp2 ;
29704
29705   arg1 = (Dali::Actor *)jarg1;
29706   argp2 = (Dali::Actor *)jarg2;
29707   if (!argp2) {
29708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29709     return ;
29710   }
29711   arg2 = *argp2;
29712   {
29713     try {
29714       (arg1)->Remove(arg2);
29715     } catch (std::out_of_range& e) {
29716       {
29717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29718       };
29719     } catch (std::exception& e) {
29720       {
29721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29722       };
29723     } catch (...) {
29724       {
29725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29726       };
29727     }
29728   }
29729 }
29730
29731
29732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29734
29735   arg1 = (Dali::Actor *)jarg1;
29736   {
29737     try {
29738       (arg1)->Unparent();
29739     } catch (std::out_of_range& e) {
29740       {
29741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29742       };
29743     } catch (std::exception& e) {
29744       {
29745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29746       };
29747     } catch (...) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29750       };
29751     }
29752   }
29753 }
29754
29755
29756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29757   unsigned int jresult ;
29758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29759   unsigned int result;
29760
29761   arg1 = (Dali::Actor *)jarg1;
29762   {
29763     try {
29764       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29765     } catch (std::out_of_range& e) {
29766       {
29767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29768       };
29769     } catch (std::exception& e) {
29770       {
29771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29772       };
29773     } catch (...) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29776       };
29777     }
29778   }
29779   jresult = result;
29780   return jresult;
29781 }
29782
29783
29784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29785   void * jresult ;
29786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29787   unsigned int arg2 ;
29788   Dali::Actor result;
29789
29790   arg1 = (Dali::Actor *)jarg1;
29791   arg2 = (unsigned int)jarg2;
29792   {
29793     try {
29794       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29795     } catch (std::out_of_range& e) {
29796       {
29797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29798       };
29799     } catch (std::exception& e) {
29800       {
29801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29802       };
29803     } catch (...) {
29804       {
29805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29806       };
29807     }
29808   }
29809   jresult = new Dali::Actor((const Dali::Actor &)result);
29810   return jresult;
29811 }
29812
29813
29814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29815   void * jresult ;
29816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29817   std::string *arg2 = 0 ;
29818   Dali::Actor result;
29819
29820   arg1 = (Dali::Actor *)jarg1;
29821   if (!jarg2) {
29822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29823     return 0;
29824   }
29825   std::string arg2_str(jarg2);
29826   arg2 = &arg2_str;
29827   {
29828     try {
29829       result = (arg1)->FindChildByName((std::string const &)*arg2);
29830     } catch (std::out_of_range& e) {
29831       {
29832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29833       };
29834     } catch (std::exception& e) {
29835       {
29836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29837       };
29838     } catch (...) {
29839       {
29840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29841       };
29842     }
29843   }
29844   jresult = new Dali::Actor((const Dali::Actor &)result);
29845
29846   //argout typemap for const std::string&
29847
29848   return jresult;
29849 }
29850
29851
29852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29853   void * jresult ;
29854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29855   unsigned int arg2 ;
29856   Dali::Actor result;
29857
29858   arg1 = (Dali::Actor *)jarg1;
29859   arg2 = (unsigned int)jarg2;
29860   {
29861     try {
29862       result = (arg1)->FindChildById(arg2);
29863     } catch (std::out_of_range& e) {
29864       {
29865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29866       };
29867     } catch (std::exception& e) {
29868       {
29869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29870       };
29871     } catch (...) {
29872       {
29873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29874       };
29875     }
29876   }
29877   jresult = new Dali::Actor((const Dali::Actor &)result);
29878   return jresult;
29879 }
29880
29881
29882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29883   void * jresult ;
29884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29885   Dali::Actor result;
29886
29887   arg1 = (Dali::Actor *)jarg1;
29888   {
29889     try {
29890       result = ((Dali::Actor const *)arg1)->GetParent();
29891     } catch (std::out_of_range& e) {
29892       {
29893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29894       };
29895     } catch (std::exception& e) {
29896       {
29897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29898       };
29899     } catch (...) {
29900       {
29901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29902       };
29903     }
29904   }
29905   jresult = new Dali::Actor((const Dali::Actor &)result);
29906   return jresult;
29907 }
29908
29909
29910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29912   Dali::Vector3 *arg2 = 0 ;
29913
29914   arg1 = (Dali::Actor *)jarg1;
29915   arg2 = (Dali::Vector3 *)jarg2;
29916   if (!arg2) {
29917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29918     return ;
29919   }
29920   {
29921     try {
29922       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29923     } catch (std::out_of_range& e) {
29924       {
29925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29926       };
29927     } catch (std::exception& e) {
29928       {
29929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29930       };
29931     } catch (...) {
29932       {
29933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29934       };
29935     }
29936   }
29937 }
29938
29939
29940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29941   void * jresult ;
29942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29943   Dali::Vector3 result;
29944
29945   arg1 = (Dali::Actor *)jarg1;
29946   {
29947     try {
29948       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29949     } catch (std::out_of_range& e) {
29950       {
29951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29952       };
29953     } catch (std::exception& e) {
29954       {
29955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29956       };
29957     } catch (...) {
29958       {
29959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29960       };
29961     }
29962   }
29963   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29964   return jresult;
29965 }
29966
29967
29968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29970   Dali::Vector3 *arg2 = 0 ;
29971
29972   arg1 = (Dali::Actor *)jarg1;
29973   arg2 = (Dali::Vector3 *)jarg2;
29974   if (!arg2) {
29975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29976     return ;
29977   }
29978   {
29979     try {
29980       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29981     } catch (std::out_of_range& e) {
29982       {
29983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29984       };
29985     } catch (std::exception& e) {
29986       {
29987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29988       };
29989     } catch (...) {
29990       {
29991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29992       };
29993     }
29994   }
29995 }
29996
29997
29998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29999   void * jresult ;
30000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30001   Dali::Vector3 result;
30002
30003   arg1 = (Dali::Actor *)jarg1;
30004   {
30005     try {
30006       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30007     } catch (std::out_of_range& e) {
30008       {
30009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30010       };
30011     } catch (std::exception& e) {
30012       {
30013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30014       };
30015     } catch (...) {
30016       {
30017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30018       };
30019     }
30020   }
30021   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30022   return jresult;
30023 }
30024
30025
30026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30027   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30028   float arg2 ;
30029   float arg3 ;
30030
30031   arg1 = (Dali::Actor *)jarg1;
30032   arg2 = (float)jarg2;
30033   arg3 = (float)jarg3;
30034   {
30035     try {
30036       (arg1)->SetSize(arg2,arg3);
30037     } catch (std::out_of_range& e) {
30038       {
30039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30040       };
30041     } catch (std::exception& e) {
30042       {
30043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30044       };
30045     } catch (...) {
30046       {
30047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30048       };
30049     }
30050   }
30051 }
30052
30053
30054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30056   float arg2 ;
30057   float arg3 ;
30058   float arg4 ;
30059
30060   arg1 = (Dali::Actor *)jarg1;
30061   arg2 = (float)jarg2;
30062   arg3 = (float)jarg3;
30063   arg4 = (float)jarg4;
30064   {
30065     try {
30066       (arg1)->SetSize(arg2,arg3,arg4);
30067     } catch (std::out_of_range& e) {
30068       {
30069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30070       };
30071     } catch (std::exception& e) {
30072       {
30073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30074       };
30075     } catch (...) {
30076       {
30077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30078       };
30079     }
30080   }
30081 }
30082
30083
30084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30086   Dali::Vector2 *arg2 = 0 ;
30087
30088   arg1 = (Dali::Actor *)jarg1;
30089   arg2 = (Dali::Vector2 *)jarg2;
30090   if (!arg2) {
30091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30092     return ;
30093   }
30094   {
30095     try {
30096       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30097     } catch (std::out_of_range& e) {
30098       {
30099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30100       };
30101     } catch (std::exception& e) {
30102       {
30103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30104       };
30105     } catch (...) {
30106       {
30107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30108       };
30109     }
30110   }
30111 }
30112
30113
30114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30116   Dali::Vector3 *arg2 = 0 ;
30117
30118   arg1 = (Dali::Actor *)jarg1;
30119   arg2 = (Dali::Vector3 *)jarg2;
30120   if (!arg2) {
30121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30122     return ;
30123   }
30124   {
30125     try {
30126       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30127     } catch (std::out_of_range& e) {
30128       {
30129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30130       };
30131     } catch (std::exception& e) {
30132       {
30133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30134       };
30135     } catch (...) {
30136       {
30137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30138       };
30139     }
30140   }
30141 }
30142
30143
30144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30145   void * jresult ;
30146   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30147   Dali::Vector3 result;
30148
30149   arg1 = (Dali::Actor *)jarg1;
30150   {
30151     try {
30152       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30153     } catch (std::out_of_range& e) {
30154       {
30155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30156       };
30157     } catch (std::exception& e) {
30158       {
30159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30160       };
30161     } catch (...) {
30162       {
30163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30164       };
30165     }
30166   }
30167   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30168   return jresult;
30169 }
30170
30171
30172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30173   void * jresult ;
30174   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30175   Dali::Vector3 result;
30176
30177   arg1 = (Dali::Actor *)jarg1;
30178   {
30179     try {
30180       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30181     } catch (std::out_of_range& e) {
30182       {
30183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30184       };
30185     } catch (std::exception& e) {
30186       {
30187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30188       };
30189     } catch (...) {
30190       {
30191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30192       };
30193     }
30194   }
30195   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30196   return jresult;
30197 }
30198
30199
30200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30201   void * jresult ;
30202   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30203   Dali::Vector3 result;
30204
30205   arg1 = (Dali::Actor *)jarg1;
30206   {
30207     try {
30208       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30209     } catch (std::out_of_range& e) {
30210       {
30211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30212       };
30213     } catch (std::exception& e) {
30214       {
30215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30216       };
30217     } catch (...) {
30218       {
30219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30220       };
30221     }
30222   }
30223   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30224   return jresult;
30225 }
30226
30227
30228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30230   float arg2 ;
30231   float arg3 ;
30232
30233   arg1 = (Dali::Actor *)jarg1;
30234   arg2 = (float)jarg2;
30235   arg3 = (float)jarg3;
30236   {
30237     try {
30238       (arg1)->SetPosition(arg2,arg3);
30239     } catch (std::out_of_range& e) {
30240       {
30241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30242       };
30243     } catch (std::exception& e) {
30244       {
30245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30246       };
30247     } catch (...) {
30248       {
30249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30250       };
30251     }
30252   }
30253 }
30254
30255
30256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30258   float arg2 ;
30259   float arg3 ;
30260   float arg4 ;
30261
30262   arg1 = (Dali::Actor *)jarg1;
30263   arg2 = (float)jarg2;
30264   arg3 = (float)jarg3;
30265   arg4 = (float)jarg4;
30266   {
30267     try {
30268       (arg1)->SetPosition(arg2,arg3,arg4);
30269     } catch (std::out_of_range& e) {
30270       {
30271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30272       };
30273     } catch (std::exception& e) {
30274       {
30275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30276       };
30277     } catch (...) {
30278       {
30279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30280       };
30281     }
30282   }
30283 }
30284
30285
30286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30287   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30288   Dali::Vector3 *arg2 = 0 ;
30289
30290   arg1 = (Dali::Actor *)jarg1;
30291   arg2 = (Dali::Vector3 *)jarg2;
30292   if (!arg2) {
30293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30294     return ;
30295   }
30296   {
30297     try {
30298       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30299     } catch (std::out_of_range& e) {
30300       {
30301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30302       };
30303     } catch (std::exception& e) {
30304       {
30305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30306       };
30307     } catch (...) {
30308       {
30309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30310       };
30311     }
30312   }
30313 }
30314
30315
30316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30317   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30318   float arg2 ;
30319
30320   arg1 = (Dali::Actor *)jarg1;
30321   arg2 = (float)jarg2;
30322   {
30323     try {
30324       (arg1)->SetX(arg2);
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_SetY(void * jarg1, float jarg2) {
30343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30344   float arg2 ;
30345
30346   arg1 = (Dali::Actor *)jarg1;
30347   arg2 = (float)jarg2;
30348   {
30349     try {
30350       (arg1)->SetY(arg2);
30351     } catch (std::out_of_range& e) {
30352       {
30353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30354       };
30355     } catch (std::exception& e) {
30356       {
30357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30358       };
30359     } catch (...) {
30360       {
30361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30362       };
30363     }
30364   }
30365 }
30366
30367
30368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30369   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30370   float arg2 ;
30371
30372   arg1 = (Dali::Actor *)jarg1;
30373   arg2 = (float)jarg2;
30374   {
30375     try {
30376       (arg1)->SetZ(arg2);
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30384       };
30385     } catch (...) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30388       };
30389     }
30390   }
30391 }
30392
30393
30394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30396   Dali::Vector3 *arg2 = 0 ;
30397
30398   arg1 = (Dali::Actor *)jarg1;
30399   arg2 = (Dali::Vector3 *)jarg2;
30400   if (!arg2) {
30401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30402     return ;
30403   }
30404   {
30405     try {
30406       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30407     } catch (std::out_of_range& e) {
30408       {
30409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30410       };
30411     } catch (std::exception& e) {
30412       {
30413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30414       };
30415     } catch (...) {
30416       {
30417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30418       };
30419     }
30420   }
30421 }
30422
30423
30424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30425   void * jresult ;
30426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30427   Dali::Vector3 result;
30428
30429   arg1 = (Dali::Actor *)jarg1;
30430   {
30431     try {
30432       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30433     } catch (std::out_of_range& e) {
30434       {
30435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30436       };
30437     } catch (std::exception& e) {
30438       {
30439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30440       };
30441     } catch (...) {
30442       {
30443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30444       };
30445     }
30446   }
30447   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30448   return jresult;
30449 }
30450
30451
30452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30453   void * jresult ;
30454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30455   Dali::Vector3 result;
30456
30457   arg1 = (Dali::Actor *)jarg1;
30458   {
30459     try {
30460       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30468       };
30469     } catch (...) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30472       };
30473     }
30474   }
30475   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30476   return jresult;
30477 }
30478
30479
30480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30481   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30482   bool arg2 ;
30483
30484   arg1 = (Dali::Actor *)jarg1;
30485   arg2 = jarg2 ? true : false;
30486   {
30487     try {
30488       (arg1)->SetInheritPosition(arg2);
30489     } catch (std::out_of_range& e) {
30490       {
30491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30492       };
30493     } catch (std::exception& e) {
30494       {
30495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30496       };
30497     } catch (...) {
30498       {
30499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30500       };
30501     }
30502   }
30503 }
30504
30505
30506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30507   int jresult ;
30508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30509   Dali::PositionInheritanceMode result;
30510
30511   arg1 = (Dali::Actor *)jarg1;
30512   {
30513     try {
30514       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30515     } catch (std::out_of_range& e) {
30516       {
30517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30518       };
30519     } catch (std::exception& e) {
30520       {
30521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30522       };
30523     } catch (...) {
30524       {
30525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30526       };
30527     }
30528   }
30529   jresult = (int)result;
30530   return jresult;
30531 }
30532
30533
30534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30535   unsigned int jresult ;
30536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30537   bool result;
30538
30539   arg1 = (Dali::Actor *)jarg1;
30540   {
30541     try {
30542       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30543     } catch (std::out_of_range& e) {
30544       {
30545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30546       };
30547     } catch (std::exception& e) {
30548       {
30549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30550       };
30551     } catch (...) {
30552       {
30553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30554       };
30555     }
30556   }
30557   jresult = result;
30558   return jresult;
30559 }
30560
30561
30562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30564   Dali::Degree *arg2 = 0 ;
30565   Dali::Vector3 *arg3 = 0 ;
30566
30567   arg1 = (Dali::Actor *)jarg1;
30568   arg2 = (Dali::Degree *)jarg2;
30569   if (!arg2) {
30570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30571     return ;
30572   }
30573   arg3 = (Dali::Vector3 *)jarg3;
30574   if (!arg3) {
30575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30576     return ;
30577   }
30578   {
30579     try {
30580       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30581     } catch (std::out_of_range& e) {
30582       {
30583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30584       };
30585     } catch (std::exception& e) {
30586       {
30587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30588       };
30589     } catch (...) {
30590       {
30591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30592       };
30593     }
30594   }
30595 }
30596
30597
30598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30600   Dali::Radian *arg2 = 0 ;
30601   Dali::Vector3 *arg3 = 0 ;
30602
30603   arg1 = (Dali::Actor *)jarg1;
30604   arg2 = (Dali::Radian *)jarg2;
30605   if (!arg2) {
30606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30607     return ;
30608   }
30609   arg3 = (Dali::Vector3 *)jarg3;
30610   if (!arg3) {
30611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30612     return ;
30613   }
30614   {
30615     try {
30616       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30617     } catch (std::out_of_range& e) {
30618       {
30619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30620       };
30621     } catch (std::exception& e) {
30622       {
30623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30624       };
30625     } catch (...) {
30626       {
30627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30628       };
30629     }
30630   }
30631 }
30632
30633
30634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30635   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30636   Dali::Quaternion *arg2 = 0 ;
30637
30638   arg1 = (Dali::Actor *)jarg1;
30639   arg2 = (Dali::Quaternion *)jarg2;
30640   if (!arg2) {
30641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30642     return ;
30643   }
30644   {
30645     try {
30646       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30647     } catch (std::out_of_range& e) {
30648       {
30649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30650       };
30651     } catch (std::exception& e) {
30652       {
30653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30654       };
30655     } catch (...) {
30656       {
30657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30658       };
30659     }
30660   }
30661 }
30662
30663
30664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30665   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30666   Dali::Degree *arg2 = 0 ;
30667   Dali::Vector3 *arg3 = 0 ;
30668
30669   arg1 = (Dali::Actor *)jarg1;
30670   arg2 = (Dali::Degree *)jarg2;
30671   if (!arg2) {
30672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30673     return ;
30674   }
30675   arg3 = (Dali::Vector3 *)jarg3;
30676   if (!arg3) {
30677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30678     return ;
30679   }
30680   {
30681     try {
30682       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
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_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30702   Dali::Radian *arg2 = 0 ;
30703   Dali::Vector3 *arg3 = 0 ;
30704
30705   arg1 = (Dali::Actor *)jarg1;
30706   arg2 = (Dali::Radian *)jarg2;
30707   if (!arg2) {
30708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30709     return ;
30710   }
30711   arg3 = (Dali::Vector3 *)jarg3;
30712   if (!arg3) {
30713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30714     return ;
30715   }
30716   {
30717     try {
30718       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30719     } catch (std::out_of_range& e) {
30720       {
30721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30722       };
30723     } catch (std::exception& e) {
30724       {
30725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30726       };
30727     } catch (...) {
30728       {
30729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30730       };
30731     }
30732   }
30733 }
30734
30735
30736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30738   Dali::Quaternion *arg2 = 0 ;
30739
30740   arg1 = (Dali::Actor *)jarg1;
30741   arg2 = (Dali::Quaternion *)jarg2;
30742   if (!arg2) {
30743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30744     return ;
30745   }
30746   {
30747     try {
30748       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30749     } catch (std::out_of_range& e) {
30750       {
30751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30752       };
30753     } catch (std::exception& e) {
30754       {
30755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30756       };
30757     } catch (...) {
30758       {
30759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30760       };
30761     }
30762   }
30763 }
30764
30765
30766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30767   void * jresult ;
30768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30769   Dali::Quaternion result;
30770
30771   arg1 = (Dali::Actor *)jarg1;
30772   {
30773     try {
30774       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30775     } catch (std::out_of_range& e) {
30776       {
30777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30778       };
30779     } catch (std::exception& e) {
30780       {
30781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30782       };
30783     } catch (...) {
30784       {
30785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30786       };
30787     }
30788   }
30789   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30796   bool arg2 ;
30797
30798   arg1 = (Dali::Actor *)jarg1;
30799   arg2 = jarg2 ? true : false;
30800   {
30801     try {
30802       (arg1)->SetInheritOrientation(arg2);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30814       };
30815     }
30816   }
30817 }
30818
30819
30820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30821   unsigned int jresult ;
30822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30823   bool result;
30824
30825   arg1 = (Dali::Actor *)jarg1;
30826   {
30827     try {
30828       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30829     } catch (std::out_of_range& e) {
30830       {
30831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30832       };
30833     } catch (std::exception& e) {
30834       {
30835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30836       };
30837     } catch (...) {
30838       {
30839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30840       };
30841     }
30842   }
30843   jresult = result;
30844   return jresult;
30845 }
30846
30847
30848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30849   void * jresult ;
30850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30851   Dali::Quaternion result;
30852
30853   arg1 = (Dali::Actor *)jarg1;
30854   {
30855     try {
30856       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30857     } catch (std::out_of_range& e) {
30858       {
30859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30860       };
30861     } catch (std::exception& e) {
30862       {
30863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30864       };
30865     } catch (...) {
30866       {
30867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30868       };
30869     }
30870   }
30871   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30872   return jresult;
30873 }
30874
30875
30876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30878   float arg2 ;
30879
30880   arg1 = (Dali::Actor *)jarg1;
30881   arg2 = (float)jarg2;
30882   {
30883     try {
30884       (arg1)->SetScale(arg2);
30885     } catch (std::out_of_range& e) {
30886       {
30887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30888       };
30889     } catch (std::exception& e) {
30890       {
30891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30892       };
30893     } catch (...) {
30894       {
30895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30896       };
30897     }
30898   }
30899 }
30900
30901
30902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30904   float arg2 ;
30905   float arg3 ;
30906   float arg4 ;
30907
30908   arg1 = (Dali::Actor *)jarg1;
30909   arg2 = (float)jarg2;
30910   arg3 = (float)jarg3;
30911   arg4 = (float)jarg4;
30912   {
30913     try {
30914       (arg1)->SetScale(arg2,arg3,arg4);
30915     } catch (std::out_of_range& e) {
30916       {
30917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30918       };
30919     } catch (std::exception& e) {
30920       {
30921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30922       };
30923     } catch (...) {
30924       {
30925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30926       };
30927     }
30928   }
30929 }
30930
30931
30932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30934   Dali::Vector3 *arg2 = 0 ;
30935
30936   arg1 = (Dali::Actor *)jarg1;
30937   arg2 = (Dali::Vector3 *)jarg2;
30938   if (!arg2) {
30939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30940     return ;
30941   }
30942   {
30943     try {
30944       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30945     } catch (std::out_of_range& e) {
30946       {
30947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30948       };
30949     } catch (std::exception& e) {
30950       {
30951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30952       };
30953     } catch (...) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30956       };
30957     }
30958   }
30959 }
30960
30961
30962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30964   Dali::Vector3 *arg2 = 0 ;
30965
30966   arg1 = (Dali::Actor *)jarg1;
30967   arg2 = (Dali::Vector3 *)jarg2;
30968   if (!arg2) {
30969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30970     return ;
30971   }
30972   {
30973     try {
30974       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30975     } catch (std::out_of_range& e) {
30976       {
30977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30978       };
30979     } catch (std::exception& e) {
30980       {
30981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30982       };
30983     } catch (...) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30986       };
30987     }
30988   }
30989 }
30990
30991
30992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30993   void * jresult ;
30994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30995   Dali::Vector3 result;
30996
30997   arg1 = (Dali::Actor *)jarg1;
30998   {
30999     try {
31000       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31001     } catch (std::out_of_range& e) {
31002       {
31003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31004       };
31005     } catch (std::exception& e) {
31006       {
31007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31008       };
31009     } catch (...) {
31010       {
31011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31012       };
31013     }
31014   }
31015   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31016   return jresult;
31017 }
31018
31019
31020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31021   void * jresult ;
31022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31023   Dali::Vector3 result;
31024
31025   arg1 = (Dali::Actor *)jarg1;
31026   {
31027     try {
31028       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (...) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31040       };
31041     }
31042   }
31043   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31044   return jresult;
31045 }
31046
31047
31048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31050   bool arg2 ;
31051
31052   arg1 = (Dali::Actor *)jarg1;
31053   arg2 = jarg2 ? true : false;
31054   {
31055     try {
31056       (arg1)->SetInheritScale(arg2);
31057     } catch (std::out_of_range& e) {
31058       {
31059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31060       };
31061     } catch (std::exception& e) {
31062       {
31063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31064       };
31065     } catch (...) {
31066       {
31067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31068       };
31069     }
31070   }
31071 }
31072
31073
31074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31075   unsigned int jresult ;
31076   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31077   bool result;
31078
31079   arg1 = (Dali::Actor *)jarg1;
31080   {
31081     try {
31082       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31083     } catch (std::out_of_range& e) {
31084       {
31085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31086       };
31087     } catch (std::exception& e) {
31088       {
31089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31090       };
31091     } catch (...) {
31092       {
31093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31094       };
31095     }
31096   }
31097   jresult = result;
31098   return jresult;
31099 }
31100
31101
31102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31103   void * jresult ;
31104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31105   Dali::Matrix result;
31106
31107   arg1 = (Dali::Actor *)jarg1;
31108   {
31109     try {
31110       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31111     } catch (std::out_of_range& e) {
31112       {
31113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (std::exception& e) {
31116       {
31117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31118       };
31119     } catch (...) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31122       };
31123     }
31124   }
31125   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31126   return jresult;
31127 }
31128
31129
31130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31132   bool arg2 ;
31133
31134   arg1 = (Dali::Actor *)jarg1;
31135   arg2 = jarg2 ? true : false;
31136   {
31137     try {
31138       (arg1)->SetVisible(arg2);
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (...) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31150       };
31151     }
31152   }
31153 }
31154
31155
31156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31157   unsigned int jresult ;
31158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31159   bool result;
31160
31161   arg1 = (Dali::Actor *)jarg1;
31162   {
31163     try {
31164       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (...) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31176       };
31177     }
31178   }
31179   jresult = result;
31180   return jresult;
31181 }
31182
31183
31184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31186   float arg2 ;
31187
31188   arg1 = (Dali::Actor *)jarg1;
31189   arg2 = (float)jarg2;
31190   {
31191     try {
31192       (arg1)->SetOpacity(arg2);
31193     } catch (std::out_of_range& e) {
31194       {
31195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31196       };
31197     } catch (std::exception& e) {
31198       {
31199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31200       };
31201     } catch (...) {
31202       {
31203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31204       };
31205     }
31206   }
31207 }
31208
31209
31210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31211   float jresult ;
31212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31213   float result;
31214
31215   arg1 = (Dali::Actor *)jarg1;
31216   {
31217     try {
31218       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31219     } catch (std::out_of_range& e) {
31220       {
31221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31222       };
31223     } catch (std::exception& e) {
31224       {
31225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31226       };
31227     } catch (...) {
31228       {
31229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31230       };
31231     }
31232   }
31233   jresult = result;
31234   return jresult;
31235 }
31236
31237
31238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31239   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31240   Dali::Vector4 *arg2 = 0 ;
31241
31242   arg1 = (Dali::Actor *)jarg1;
31243   arg2 = (Dali::Vector4 *)jarg2;
31244   if (!arg2) {
31245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31246     return ;
31247   }
31248   {
31249     try {
31250       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31251     } catch (std::out_of_range& e) {
31252       {
31253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31254       };
31255     } catch (std::exception& e) {
31256       {
31257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31258       };
31259     } catch (...) {
31260       {
31261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31262       };
31263     }
31264   }
31265 }
31266
31267
31268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31269   void * jresult ;
31270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31271   Dali::Vector4 result;
31272
31273   arg1 = (Dali::Actor *)jarg1;
31274   {
31275     try {
31276       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31277     } catch (std::out_of_range& e) {
31278       {
31279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31280       };
31281     } catch (std::exception& e) {
31282       {
31283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31284       };
31285     } catch (...) {
31286       {
31287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31288       };
31289     }
31290   }
31291   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31292   return jresult;
31293 }
31294
31295
31296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31297   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31298   Dali::ColorMode arg2 ;
31299
31300   arg1 = (Dali::Actor *)jarg1;
31301   arg2 = (Dali::ColorMode)jarg2;
31302   {
31303     try {
31304       (arg1)->SetColorMode(arg2);
31305     } catch (std::out_of_range& e) {
31306       {
31307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31308       };
31309     } catch (std::exception& e) {
31310       {
31311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31312       };
31313     } catch (...) {
31314       {
31315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31316       };
31317     }
31318   }
31319 }
31320
31321
31322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31323   int jresult ;
31324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31325   Dali::ColorMode result;
31326
31327   arg1 = (Dali::Actor *)jarg1;
31328   {
31329     try {
31330       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31331     } catch (std::out_of_range& e) {
31332       {
31333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31334       };
31335     } catch (std::exception& e) {
31336       {
31337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31338       };
31339     } catch (...) {
31340       {
31341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31342       };
31343     }
31344   }
31345   jresult = (int)result;
31346   return jresult;
31347 }
31348
31349
31350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31351   void * jresult ;
31352   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31353   Dali::Vector4 result;
31354
31355   arg1 = (Dali::Actor *)jarg1;
31356   {
31357     try {
31358       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31359     } catch (std::out_of_range& e) {
31360       {
31361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31362       };
31363     } catch (std::exception& e) {
31364       {
31365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31366       };
31367     } catch (...) {
31368       {
31369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31370       };
31371     }
31372   }
31373   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31374   return jresult;
31375 }
31376
31377
31378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31380   Dali::DrawMode::Type arg2 ;
31381
31382   arg1 = (Dali::Actor *)jarg1;
31383   arg2 = (Dali::DrawMode::Type)jarg2;
31384   {
31385     try {
31386       (arg1)->SetDrawMode(arg2);
31387     } catch (std::out_of_range& e) {
31388       {
31389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31390       };
31391     } catch (std::exception& e) {
31392       {
31393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31394       };
31395     } catch (...) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31398       };
31399     }
31400   }
31401 }
31402
31403
31404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31405   int jresult ;
31406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31407   Dali::DrawMode::Type result;
31408
31409   arg1 = (Dali::Actor *)jarg1;
31410   {
31411     try {
31412       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31413     } catch (std::out_of_range& e) {
31414       {
31415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31416       };
31417     } catch (std::exception& e) {
31418       {
31419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31420       };
31421     } catch (...) {
31422       {
31423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31424       };
31425     }
31426   }
31427   jresult = (int)result;
31428   return jresult;
31429 }
31430
31431
31432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31434   bool arg2 ;
31435
31436   arg1 = (Dali::Actor *)jarg1;
31437   arg2 = jarg2 ? true : false;
31438   {
31439     try {
31440       (arg1)->SetSensitive(arg2);
31441     } catch (std::out_of_range& e) {
31442       {
31443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31444       };
31445     } catch (std::exception& e) {
31446       {
31447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31448       };
31449     } catch (...) {
31450       {
31451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31452       };
31453     }
31454   }
31455 }
31456
31457
31458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31459   unsigned int jresult ;
31460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31461   bool result;
31462
31463   arg1 = (Dali::Actor *)jarg1;
31464   {
31465     try {
31466       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31467     } catch (std::out_of_range& e) {
31468       {
31469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (std::exception& e) {
31472       {
31473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481   jresult = result;
31482   return jresult;
31483 }
31484
31485
31486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31487   unsigned int jresult ;
31488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31489   float *arg2 = 0 ;
31490   float *arg3 = 0 ;
31491   float arg4 ;
31492   float arg5 ;
31493   bool result;
31494
31495   arg1 = (Dali::Actor *)jarg1;
31496   arg2 = (float *)jarg2;
31497   arg3 = (float *)jarg3;
31498   arg4 = (float)jarg4;
31499   arg5 = (float)jarg5;
31500   {
31501     try {
31502       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31503     } catch (std::out_of_range& e) {
31504       {
31505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31506       };
31507     } catch (std::exception& e) {
31508       {
31509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31510       };
31511     } catch (...) {
31512       {
31513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31514       };
31515     }
31516   }
31517   jresult = result;
31518   return jresult;
31519 }
31520
31521
31522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31524   bool arg2 ;
31525
31526   arg1 = (Dali::Actor *)jarg1;
31527   arg2 = jarg2 ? true : false;
31528   {
31529     try {
31530       (arg1)->SetLeaveRequired(arg2);
31531     } catch (std::out_of_range& e) {
31532       {
31533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31534       };
31535     } catch (std::exception& e) {
31536       {
31537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31538       };
31539     } catch (...) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31542       };
31543     }
31544   }
31545 }
31546
31547
31548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31549   unsigned int jresult ;
31550   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31551   bool result;
31552
31553   arg1 = (Dali::Actor *)jarg1;
31554   {
31555     try {
31556       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31557     } catch (std::out_of_range& e) {
31558       {
31559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (std::exception& e) {
31562       {
31563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571   jresult = result;
31572   return jresult;
31573 }
31574
31575
31576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31577   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31578   bool arg2 ;
31579
31580   arg1 = (Dali::Actor *)jarg1;
31581   arg2 = jarg2 ? true : false;
31582   {
31583     try {
31584       (arg1)->SetKeyboardFocusable(arg2);
31585     } catch (std::out_of_range& e) {
31586       {
31587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31588       };
31589     } catch (std::exception& e) {
31590       {
31591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31592       };
31593     } catch (...) {
31594       {
31595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31596       };
31597     }
31598   }
31599 }
31600
31601
31602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31603   unsigned int jresult ;
31604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31605   bool result;
31606
31607   arg1 = (Dali::Actor *)jarg1;
31608   {
31609     try {
31610       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31611     } catch (std::out_of_range& e) {
31612       {
31613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31614       };
31615     } catch (std::exception& e) {
31616       {
31617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31618       };
31619     } catch (...) {
31620       {
31621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31622       };
31623     }
31624   }
31625   jresult = result;
31626   return jresult;
31627 }
31628
31629
31630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31632   Dali::ResizePolicy::Type arg2 ;
31633   Dali::Dimension::Type arg3 ;
31634
31635   arg1 = (Dali::Actor *)jarg1;
31636   arg2 = (Dali::ResizePolicy::Type)jarg2;
31637   arg3 = (Dali::Dimension::Type)jarg3;
31638   {
31639     try {
31640       (arg1)->SetResizePolicy(arg2,arg3);
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 int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31659   int jresult ;
31660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31661   Dali::Dimension::Type arg2 ;
31662   Dali::ResizePolicy::Type result;
31663
31664   arg1 = (Dali::Actor *)jarg1;
31665   arg2 = (Dali::Dimension::Type)jarg2;
31666   {
31667     try {
31668       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31669     } catch (std::out_of_range& e) {
31670       {
31671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31672       };
31673     } catch (std::exception& e) {
31674       {
31675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31676       };
31677     } catch (...) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31680       };
31681     }
31682   }
31683   jresult = (int)result;
31684   return jresult;
31685 }
31686
31687
31688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31690   Dali::SizeScalePolicy::Type arg2 ;
31691
31692   arg1 = (Dali::Actor *)jarg1;
31693   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31694   {
31695     try {
31696       (arg1)->SetSizeScalePolicy(arg2);
31697     } catch (std::out_of_range& e) {
31698       {
31699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31700       };
31701     } catch (std::exception& e) {
31702       {
31703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31704       };
31705     } catch (...) {
31706       {
31707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31708       };
31709     }
31710   }
31711 }
31712
31713
31714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31715   int jresult ;
31716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31717   Dali::SizeScalePolicy::Type result;
31718
31719   arg1 = (Dali::Actor *)jarg1;
31720   {
31721     try {
31722       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31723     } catch (std::out_of_range& e) {
31724       {
31725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31726       };
31727     } catch (std::exception& e) {
31728       {
31729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31730       };
31731     } catch (...) {
31732       {
31733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31734       };
31735     }
31736   }
31737   jresult = (int)result;
31738   return jresult;
31739 }
31740
31741
31742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31744   Dali::Vector3 *arg2 = 0 ;
31745
31746   arg1 = (Dali::Actor *)jarg1;
31747   arg2 = (Dali::Vector3 *)jarg2;
31748   if (!arg2) {
31749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31750     return ;
31751   }
31752   {
31753     try {
31754       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31755     } catch (std::out_of_range& e) {
31756       {
31757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31758       };
31759     } catch (std::exception& e) {
31760       {
31761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31762       };
31763     } catch (...) {
31764       {
31765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31766       };
31767     }
31768   }
31769 }
31770
31771
31772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31773   void * jresult ;
31774   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31775   Dali::Vector3 result;
31776
31777   arg1 = (Dali::Actor *)jarg1;
31778   {
31779     try {
31780       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31781     } catch (std::out_of_range& e) {
31782       {
31783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31784       };
31785     } catch (std::exception& e) {
31786       {
31787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31788       };
31789     } catch (...) {
31790       {
31791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31792       };
31793     }
31794   }
31795   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31796   return jresult;
31797 }
31798
31799
31800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31801   float jresult ;
31802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31803   float arg2 ;
31804   float result;
31805
31806   arg1 = (Dali::Actor *)jarg1;
31807   arg2 = (float)jarg2;
31808   {
31809     try {
31810       result = (float)(arg1)->GetHeightForWidth(arg2);
31811     } catch (std::out_of_range& e) {
31812       {
31813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31814       };
31815     } catch (std::exception& e) {
31816       {
31817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31818       };
31819     } catch (...) {
31820       {
31821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31822       };
31823     }
31824   }
31825   jresult = result;
31826   return jresult;
31827 }
31828
31829
31830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31831   float jresult ;
31832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31833   float arg2 ;
31834   float result;
31835
31836   arg1 = (Dali::Actor *)jarg1;
31837   arg2 = (float)jarg2;
31838   {
31839     try {
31840       result = (float)(arg1)->GetWidthForHeight(arg2);
31841     } catch (std::out_of_range& e) {
31842       {
31843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31844       };
31845     } catch (std::exception& e) {
31846       {
31847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31848       };
31849     } catch (...) {
31850       {
31851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31852       };
31853     }
31854   }
31855   jresult = result;
31856   return jresult;
31857 }
31858
31859
31860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31861   float jresult ;
31862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31863   Dali::Dimension::Type arg2 ;
31864   float result;
31865
31866   arg1 = (Dali::Actor *)jarg1;
31867   arg2 = (Dali::Dimension::Type)jarg2;
31868   {
31869     try {
31870       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31871     } catch (std::out_of_range& e) {
31872       {
31873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31874       };
31875     } catch (std::exception& e) {
31876       {
31877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31878       };
31879     } catch (...) {
31880       {
31881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31882       };
31883     }
31884   }
31885   jresult = result;
31886   return jresult;
31887 }
31888
31889
31890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31892   Dali::Padding *arg2 = 0 ;
31893
31894   arg1 = (Dali::Actor *)jarg1;
31895   arg2 = (Dali::Padding *)jarg2;
31896   if (!arg2) {
31897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31898     return ;
31899   }
31900   {
31901     try {
31902       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31903     } catch (std::out_of_range& e) {
31904       {
31905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31906       };
31907     } catch (std::exception& e) {
31908       {
31909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31910       };
31911     } catch (...) {
31912       {
31913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31914       };
31915     }
31916   }
31917 }
31918
31919
31920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31922   Dali::Padding *arg2 = 0 ;
31923
31924   arg1 = (Dali::Actor *)jarg1;
31925   arg2 = (Dali::Padding *)jarg2;
31926   if (!arg2) {
31927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31928     return ;
31929   }
31930   {
31931     try {
31932       ((Dali::Actor const *)arg1)->GetPadding(*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_SetMinimumSize(void * jarg1, void * jarg2) {
31951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31952   Dali::Vector2 *arg2 = 0 ;
31953
31954   arg1 = (Dali::Actor *)jarg1;
31955   arg2 = (Dali::Vector2 *)jarg2;
31956   if (!arg2) {
31957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31958     return ;
31959   }
31960   {
31961     try {
31962       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31963     } catch (std::out_of_range& e) {
31964       {
31965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31966       };
31967     } catch (std::exception& e) {
31968       {
31969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31970       };
31971     } catch (...) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31974       };
31975     }
31976   }
31977 }
31978
31979
31980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31981   void * jresult ;
31982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31983   Dali::Vector2 result;
31984
31985   arg1 = (Dali::Actor *)jarg1;
31986   {
31987     try {
31988       result = (arg1)->GetMinimumSize();
31989     } catch (std::out_of_range& e) {
31990       {
31991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31992       };
31993     } catch (std::exception& e) {
31994       {
31995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31996       };
31997     } catch (...) {
31998       {
31999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32000       };
32001     }
32002   }
32003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32004   return jresult;
32005 }
32006
32007
32008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32010   Dali::Vector2 *arg2 = 0 ;
32011
32012   arg1 = (Dali::Actor *)jarg1;
32013   arg2 = (Dali::Vector2 *)jarg2;
32014   if (!arg2) {
32015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32016     return ;
32017   }
32018   {
32019     try {
32020       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32021     } catch (std::out_of_range& e) {
32022       {
32023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32024       };
32025     } catch (std::exception& e) {
32026       {
32027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32028       };
32029     } catch (...) {
32030       {
32031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32032       };
32033     }
32034   }
32035 }
32036
32037
32038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32039   void * jresult ;
32040   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32041   Dali::Vector2 result;
32042
32043   arg1 = (Dali::Actor *)jarg1;
32044   {
32045     try {
32046       result = (arg1)->GetMaximumSize();
32047     } catch (std::out_of_range& e) {
32048       {
32049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32050       };
32051     } catch (std::exception& e) {
32052       {
32053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32054       };
32055     } catch (...) {
32056       {
32057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32058       };
32059     }
32060   }
32061   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32062   return jresult;
32063 }
32064
32065
32066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32067   int jresult ;
32068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32069   int result;
32070
32071   arg1 = (Dali::Actor *)jarg1;
32072   {
32073     try {
32074       result = (int)(arg1)->GetHierarchyDepth();
32075     } catch (std::out_of_range& e) {
32076       {
32077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32078       };
32079     } catch (std::exception& e) {
32080       {
32081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32082       };
32083     } catch (...) {
32084       {
32085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32086       };
32087     }
32088   }
32089   jresult = result;
32090   return jresult;
32091 }
32092
32093
32094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32095   unsigned int jresult ;
32096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32097   Dali::Renderer *arg2 = 0 ;
32098   unsigned int result;
32099
32100   arg1 = (Dali::Actor *)jarg1;
32101   arg2 = (Dali::Renderer *)jarg2;
32102   if (!arg2) {
32103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32104     return 0;
32105   }
32106   {
32107     try {
32108       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32109     } catch (std::out_of_range& e) {
32110       {
32111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32112       };
32113     } catch (std::exception& e) {
32114       {
32115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32116       };
32117     } catch (...) {
32118       {
32119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32120       };
32121     }
32122   }
32123   jresult = result;
32124   return jresult;
32125 }
32126
32127
32128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32129   unsigned int jresult ;
32130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32131   unsigned int result;
32132
32133   arg1 = (Dali::Actor *)jarg1;
32134   {
32135     try {
32136       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32137     } catch (std::out_of_range& e) {
32138       {
32139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32140       };
32141     } catch (std::exception& e) {
32142       {
32143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32144       };
32145     } catch (...) {
32146       {
32147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32148       };
32149     }
32150   }
32151   jresult = result;
32152   return jresult;
32153 }
32154
32155
32156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32157   void * jresult ;
32158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32159   unsigned int arg2 ;
32160   Dali::Renderer result;
32161
32162   arg1 = (Dali::Actor *)jarg1;
32163   arg2 = (unsigned int)jarg2;
32164   {
32165     try {
32166       result = (arg1)->GetRendererAt(arg2);
32167     } catch (std::out_of_range& e) {
32168       {
32169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32170       };
32171     } catch (std::exception& e) {
32172       {
32173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32174       };
32175     } catch (...) {
32176       {
32177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32178       };
32179     }
32180   }
32181   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32182   return jresult;
32183 }
32184
32185
32186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32188   Dali::Renderer *arg2 = 0 ;
32189
32190   arg1 = (Dali::Actor *)jarg1;
32191   arg2 = (Dali::Renderer *)jarg2;
32192   if (!arg2) {
32193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32194     return ;
32195   }
32196   {
32197     try {
32198       (arg1)->RemoveRenderer(*arg2);
32199     } catch (std::out_of_range& e) {
32200       {
32201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32202       };
32203     } catch (std::exception& e) {
32204       {
32205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32206       };
32207     } catch (...) {
32208       {
32209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32210       };
32211     }
32212   }
32213 }
32214
32215
32216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32218   unsigned int arg2 ;
32219
32220   arg1 = (Dali::Actor *)jarg1;
32221   arg2 = (unsigned int)jarg2;
32222   {
32223     try {
32224       (arg1)->RemoveRenderer(arg2);
32225     } catch (std::out_of_range& e) {
32226       {
32227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32228       };
32229     } catch (std::exception& e) {
32230       {
32231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32232       };
32233     } catch (...) {
32234       {
32235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32236       };
32237     }
32238   }
32239 }
32240
32241
32242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32243   void * jresult ;
32244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32245   Dali::Actor::TouchSignalType *result = 0 ;
32246
32247   arg1 = (Dali::Actor *)jarg1;
32248   {
32249     try {
32250       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32251     } catch (std::out_of_range& e) {
32252       {
32253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (std::exception& e) {
32256       {
32257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265   jresult = (void *)result;
32266   return jresult;
32267 }
32268
32269
32270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32271   void * jresult ;
32272   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32273   Dali::Actor::TouchDataSignalType *result = 0 ;
32274
32275   arg1 = (Dali::Actor *)jarg1;
32276   {
32277     try {
32278       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32279     } catch (std::out_of_range& e) {
32280       {
32281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32282       };
32283     } catch (std::exception& e) {
32284       {
32285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32286       };
32287     } catch (...) {
32288       {
32289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32290       };
32291     }
32292   }
32293   jresult = (void *)result;
32294   return jresult;
32295 }
32296
32297
32298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32299   void * jresult ;
32300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32301   Dali::Actor::HoverSignalType *result = 0 ;
32302
32303   arg1 = (Dali::Actor *)jarg1;
32304   {
32305     try {
32306       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32307     } catch (std::out_of_range& e) {
32308       {
32309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32310       };
32311     } catch (std::exception& e) {
32312       {
32313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32314       };
32315     } catch (...) {
32316       {
32317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32318       };
32319     }
32320   }
32321   jresult = (void *)result;
32322   return jresult;
32323 }
32324
32325
32326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32327   void * jresult ;
32328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32329   Dali::Actor::WheelEventSignalType *result = 0 ;
32330
32331   arg1 = (Dali::Actor *)jarg1;
32332   {
32333     try {
32334       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32335     } catch (std::out_of_range& e) {
32336       {
32337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32338       };
32339     } catch (std::exception& e) {
32340       {
32341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32342       };
32343     } catch (...) {
32344       {
32345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32346       };
32347     }
32348   }
32349   jresult = (void *)result;
32350   return jresult;
32351 }
32352
32353
32354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32355   void * jresult ;
32356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32357   Dali::Actor::OnStageSignalType *result = 0 ;
32358
32359   arg1 = (Dali::Actor *)jarg1;
32360   {
32361     try {
32362       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32363     } catch (std::out_of_range& e) {
32364       {
32365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32366       };
32367     } catch (std::exception& e) {
32368       {
32369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32370       };
32371     } catch (...) {
32372       {
32373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32374       };
32375     }
32376   }
32377   jresult = (void *)result;
32378   return jresult;
32379 }
32380
32381
32382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32383   void * jresult ;
32384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32385   Dali::Actor::OffStageSignalType *result = 0 ;
32386
32387   arg1 = (Dali::Actor *)jarg1;
32388   {
32389     try {
32390       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (...) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32402       };
32403     }
32404   }
32405   jresult = (void *)result;
32406   return jresult;
32407 }
32408
32409
32410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32411   void * jresult ;
32412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32413   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32414
32415   arg1 = (Dali::Actor *)jarg1;
32416   {
32417     try {
32418       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32419     } catch (std::out_of_range& e) {
32420       {
32421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32422       };
32423     } catch (std::exception& e) {
32424       {
32425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32426       };
32427     } catch (...) {
32428       {
32429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32430       };
32431     }
32432   }
32433   jresult = (void *)result;
32434   return jresult;
32435 }
32436
32437
32438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32439   Dali::Actor *arg1 = 0 ;
32440
32441   arg1 = (Dali::Actor *)jarg1;
32442   if (!arg1) {
32443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32444     return ;
32445   }
32446   {
32447     try {
32448       Dali::UnparentAndReset(*arg1);
32449     } catch (std::out_of_range& e) {
32450       {
32451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32452       };
32453     } catch (std::exception& e) {
32454       {
32455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32456       };
32457     } catch (...) {
32458       {
32459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32460       };
32461     }
32462   }
32463 }
32464
32465
32466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32467   int jresult ;
32468   int result;
32469
32470   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32471   jresult = (int)result;
32472   return jresult;
32473 }
32474
32475
32476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32477   int jresult ;
32478   int result;
32479
32480   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32481   jresult = (int)result;
32482   return jresult;
32483 }
32484
32485
32486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32487   int jresult ;
32488   int result;
32489
32490   result = (int)Dali::Layer::Property::BEHAVIOR;
32491   jresult = (int)result;
32492   return jresult;
32493 }
32494
32495
32496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32497   void * jresult ;
32498   Dali::Layer::Property *result = 0 ;
32499
32500   {
32501     try {
32502       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32503     } catch (std::out_of_range& e) {
32504       {
32505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32506       };
32507     } catch (std::exception& e) {
32508       {
32509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32510       };
32511     } catch (...) {
32512       {
32513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32514       };
32515     }
32516   }
32517   jresult = (void *)result;
32518   return jresult;
32519 }
32520
32521
32522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32523   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32524
32525   arg1 = (Dali::Layer::Property *)jarg1;
32526   {
32527     try {
32528       delete arg1;
32529     } catch (std::out_of_range& e) {
32530       {
32531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32532       };
32533     } catch (std::exception& e) {
32534       {
32535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32536       };
32537     } catch (...) {
32538       {
32539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32540       };
32541     }
32542   }
32543 }
32544
32545
32546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32547   void * jresult ;
32548   Dali::Layer *result = 0 ;
32549
32550   {
32551     try {
32552       result = (Dali::Layer *)new Dali::Layer();
32553     } catch (std::out_of_range& e) {
32554       {
32555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32556       };
32557     } catch (std::exception& e) {
32558       {
32559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32560       };
32561     } catch (...) {
32562       {
32563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32564       };
32565     }
32566   }
32567   jresult = (void *)result;
32568   return jresult;
32569 }
32570
32571
32572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32573   void * jresult ;
32574   Dali::Layer result;
32575
32576   {
32577     try {
32578       result = Dali::Layer::New();
32579     } catch (std::out_of_range& e) {
32580       {
32581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (std::exception& e) {
32584       {
32585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32586       };
32587     } catch (...) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32590       };
32591     }
32592   }
32593   jresult = new Dali::Layer((const Dali::Layer &)result);
32594   return jresult;
32595 }
32596
32597
32598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32599   void * jresult ;
32600   Dali::BaseHandle arg1 ;
32601   Dali::BaseHandle *argp1 ;
32602   Dali::Layer result;
32603
32604   argp1 = (Dali::BaseHandle *)jarg1;
32605   if (!argp1) {
32606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32607     return 0;
32608   }
32609   arg1 = *argp1;
32610   {
32611     try {
32612       result = Dali::Layer::DownCast(arg1);
32613     } catch (std::out_of_range& e) {
32614       {
32615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32616       };
32617     } catch (std::exception& e) {
32618       {
32619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32620       };
32621     } catch (...) {
32622       {
32623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32624       };
32625     }
32626   }
32627   jresult = new Dali::Layer((const Dali::Layer &)result);
32628   return jresult;
32629 }
32630
32631
32632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32633   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32634
32635   arg1 = (Dali::Layer *)jarg1;
32636   {
32637     try {
32638       delete arg1;
32639     } catch (std::out_of_range& e) {
32640       {
32641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32642       };
32643     } catch (std::exception& e) {
32644       {
32645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32646       };
32647     } catch (...) {
32648       {
32649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32650       };
32651     }
32652   }
32653 }
32654
32655
32656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32657   void * jresult ;
32658   Dali::Layer *arg1 = 0 ;
32659   Dali::Layer *result = 0 ;
32660
32661   arg1 = (Dali::Layer *)jarg1;
32662   if (!arg1) {
32663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32664     return 0;
32665   }
32666   {
32667     try {
32668       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32669     } catch (std::out_of_range& e) {
32670       {
32671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32672       };
32673     } catch (std::exception& e) {
32674       {
32675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32676       };
32677     } catch (...) {
32678       {
32679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32680       };
32681     }
32682   }
32683   jresult = (void *)result;
32684   return jresult;
32685 }
32686
32687
32688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32689   void * jresult ;
32690   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32691   Dali::Layer *arg2 = 0 ;
32692   Dali::Layer *result = 0 ;
32693
32694   arg1 = (Dali::Layer *)jarg1;
32695   arg2 = (Dali::Layer *)jarg2;
32696   if (!arg2) {
32697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32698     return 0;
32699   }
32700   {
32701     try {
32702       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32703     } catch (std::out_of_range& e) {
32704       {
32705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32706       };
32707     } catch (std::exception& e) {
32708       {
32709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32710       };
32711     } catch (...) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32714       };
32715     }
32716   }
32717   jresult = (void *)result;
32718   return jresult;
32719 }
32720
32721
32722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32723   unsigned int jresult ;
32724   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32725   unsigned int result;
32726
32727   arg1 = (Dali::Layer *)jarg1;
32728   {
32729     try {
32730       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32731     } catch (std::out_of_range& e) {
32732       {
32733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32734       };
32735     } catch (std::exception& e) {
32736       {
32737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32738       };
32739     } catch (...) {
32740       {
32741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32742       };
32743     }
32744   }
32745   jresult = result;
32746   return jresult;
32747 }
32748
32749
32750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32751   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32752
32753   arg1 = (Dali::Layer *)jarg1;
32754   {
32755     try {
32756       (arg1)->Raise();
32757     } catch (std::out_of_range& e) {
32758       {
32759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32760       };
32761     } catch (std::exception& e) {
32762       {
32763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32764       };
32765     } catch (...) {
32766       {
32767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32768       };
32769     }
32770   }
32771 }
32772
32773
32774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32775   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32776
32777   arg1 = (Dali::Layer *)jarg1;
32778   {
32779     try {
32780       (arg1)->Lower();
32781     } catch (std::out_of_range& e) {
32782       {
32783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32784       };
32785     } catch (std::exception& e) {
32786       {
32787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32788       };
32789     } catch (...) {
32790       {
32791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32792       };
32793     }
32794   }
32795 }
32796
32797
32798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32799   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32800   Dali::Layer arg2 ;
32801   Dali::Layer *argp2 ;
32802
32803   arg1 = (Dali::Layer *)jarg1;
32804   argp2 = (Dali::Layer *)jarg2;
32805   if (!argp2) {
32806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32807     return ;
32808   }
32809   arg2 = *argp2;
32810   {
32811     try {
32812       (arg1)->RaiseAbove(arg2);
32813     } catch (std::out_of_range& e) {
32814       {
32815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32816       };
32817     } catch (std::exception& e) {
32818       {
32819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32820       };
32821     } catch (...) {
32822       {
32823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32824       };
32825     }
32826   }
32827 }
32828
32829
32830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32831   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32832   Dali::Layer arg2 ;
32833   Dali::Layer *argp2 ;
32834
32835   arg1 = (Dali::Layer *)jarg1;
32836   argp2 = (Dali::Layer *)jarg2;
32837   if (!argp2) {
32838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32839     return ;
32840   }
32841   arg2 = *argp2;
32842   {
32843     try {
32844       (arg1)->LowerBelow(arg2);
32845     } catch (std::out_of_range& e) {
32846       {
32847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32848       };
32849     } catch (std::exception& e) {
32850       {
32851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32852       };
32853     } catch (...) {
32854       {
32855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32856       };
32857     }
32858   }
32859 }
32860
32861
32862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32863   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32864
32865   arg1 = (Dali::Layer *)jarg1;
32866   {
32867     try {
32868       (arg1)->RaiseToTop();
32869     } catch (std::out_of_range& e) {
32870       {
32871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32872       };
32873     } catch (std::exception& e) {
32874       {
32875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32876       };
32877     } catch (...) {
32878       {
32879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32880       };
32881     }
32882   }
32883 }
32884
32885
32886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32887   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32888
32889   arg1 = (Dali::Layer *)jarg1;
32890   {
32891     try {
32892       (arg1)->LowerToBottom();
32893     } catch (std::out_of_range& e) {
32894       {
32895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32896       };
32897     } catch (std::exception& e) {
32898       {
32899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32900       };
32901     } catch (...) {
32902       {
32903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32904       };
32905     }
32906   }
32907 }
32908
32909
32910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32911   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32912   Dali::Layer arg2 ;
32913   Dali::Layer *argp2 ;
32914
32915   arg1 = (Dali::Layer *)jarg1;
32916   argp2 = (Dali::Layer *)jarg2;
32917   if (!argp2) {
32918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32919     return ;
32920   }
32921   arg2 = *argp2;
32922   {
32923     try {
32924       (arg1)->MoveAbove(arg2);
32925     } catch (std::out_of_range& e) {
32926       {
32927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32928       };
32929     } catch (std::exception& e) {
32930       {
32931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32932       };
32933     } catch (...) {
32934       {
32935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32936       };
32937     }
32938   }
32939 }
32940
32941
32942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32943   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32944   Dali::Layer arg2 ;
32945   Dali::Layer *argp2 ;
32946
32947   arg1 = (Dali::Layer *)jarg1;
32948   argp2 = (Dali::Layer *)jarg2;
32949   if (!argp2) {
32950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32951     return ;
32952   }
32953   arg2 = *argp2;
32954   {
32955     try {
32956       (arg1)->MoveBelow(arg2);
32957     } catch (std::out_of_range& e) {
32958       {
32959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32960       };
32961     } catch (std::exception& e) {
32962       {
32963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32964       };
32965     } catch (...) {
32966       {
32967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32968       };
32969     }
32970   }
32971 }
32972
32973
32974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32975   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32976   Dali::Layer::Behavior arg2 ;
32977
32978   arg1 = (Dali::Layer *)jarg1;
32979   arg2 = (Dali::Layer::Behavior)jarg2;
32980   {
32981     try {
32982       (arg1)->SetBehavior(arg2);
32983     } catch (std::out_of_range& e) {
32984       {
32985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32986       };
32987     } catch (std::exception& e) {
32988       {
32989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32990       };
32991     } catch (...) {
32992       {
32993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32994       };
32995     }
32996   }
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33001   int jresult ;
33002   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33003   Dali::Layer::Behavior result;
33004
33005   arg1 = (Dali::Layer *)jarg1;
33006   {
33007     try {
33008       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33009     } catch (std::out_of_range& e) {
33010       {
33011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33012       };
33013     } catch (std::exception& e) {
33014       {
33015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33016       };
33017     } catch (...) {
33018       {
33019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33020       };
33021     }
33022   }
33023   jresult = (int)result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33029   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33030   bool arg2 ;
33031
33032   arg1 = (Dali::Layer *)jarg1;
33033   arg2 = jarg2 ? true : false;
33034   {
33035     try {
33036       (arg1)->SetClipping(arg2);
33037     } catch (std::out_of_range& e) {
33038       {
33039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33040       };
33041     } catch (std::exception& e) {
33042       {
33043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33044       };
33045     } catch (...) {
33046       {
33047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33048       };
33049     }
33050   }
33051 }
33052
33053
33054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33055   unsigned int jresult ;
33056   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33057   bool result;
33058
33059   arg1 = (Dali::Layer *)jarg1;
33060   {
33061     try {
33062       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33063     } catch (std::out_of_range& e) {
33064       {
33065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33066       };
33067     } catch (std::exception& e) {
33068       {
33069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33070       };
33071     } catch (...) {
33072       {
33073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33074       };
33075     }
33076   }
33077   jresult = result;
33078   return jresult;
33079 }
33080
33081
33082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33083   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33084   int arg2 ;
33085   int arg3 ;
33086   int arg4 ;
33087   int arg5 ;
33088
33089   arg1 = (Dali::Layer *)jarg1;
33090   arg2 = (int)jarg2;
33091   arg3 = (int)jarg3;
33092   arg4 = (int)jarg4;
33093   arg5 = (int)jarg5;
33094   {
33095     try {
33096       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33097     } catch (std::out_of_range& e) {
33098       {
33099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33100       };
33101     } catch (std::exception& e) {
33102       {
33103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33104       };
33105     } catch (...) {
33106       {
33107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33108       };
33109     }
33110   }
33111 }
33112
33113
33114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33115   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33116   Dali::ClippingBox arg2 ;
33117   Dali::ClippingBox *argp2 ;
33118
33119   arg1 = (Dali::Layer *)jarg1;
33120   argp2 = (Dali::ClippingBox *)jarg2;
33121   if (!argp2) {
33122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33123     return ;
33124   }
33125   arg2 = *argp2;
33126   {
33127     try {
33128       (arg1)->SetClippingBox(arg2);
33129     } catch (std::out_of_range& e) {
33130       {
33131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33132       };
33133     } catch (std::exception& e) {
33134       {
33135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33136       };
33137     } catch (...) {
33138       {
33139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33140       };
33141     }
33142   }
33143 }
33144
33145
33146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33147   void * jresult ;
33148   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33149   Dali::ClippingBox result;
33150
33151   arg1 = (Dali::Layer *)jarg1;
33152   {
33153     try {
33154       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33155     } catch (std::out_of_range& e) {
33156       {
33157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33158       };
33159     } catch (std::exception& e) {
33160       {
33161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33162       };
33163     } catch (...) {
33164       {
33165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33166       };
33167     }
33168   }
33169   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33170   return jresult;
33171 }
33172
33173
33174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33175   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33176   bool arg2 ;
33177
33178   arg1 = (Dali::Layer *)jarg1;
33179   arg2 = jarg2 ? true : false;
33180   {
33181     try {
33182       (arg1)->SetDepthTestDisabled(arg2);
33183     } catch (std::out_of_range& e) {
33184       {
33185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33186       };
33187     } catch (std::exception& e) {
33188       {
33189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33190       };
33191     } catch (...) {
33192       {
33193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33194       };
33195     }
33196   }
33197 }
33198
33199
33200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33201   unsigned int jresult ;
33202   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33203   bool result;
33204
33205   arg1 = (Dali::Layer *)jarg1;
33206   {
33207     try {
33208       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33209     } catch (std::out_of_range& e) {
33210       {
33211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33212       };
33213     } catch (std::exception& e) {
33214       {
33215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33216       };
33217     } catch (...) {
33218       {
33219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33220       };
33221     }
33222   }
33223   jresult = result;
33224   return jresult;
33225 }
33226
33227
33228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33229   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33230   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33231
33232   arg1 = (Dali::Layer *)jarg1;
33233   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33234   {
33235     try {
33236       (arg1)->SetSortFunction(arg2);
33237     } catch (std::out_of_range& e) {
33238       {
33239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33240       };
33241     } catch (std::exception& e) {
33242       {
33243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33244       };
33245     } catch (...) {
33246       {
33247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33248       };
33249     }
33250   }
33251 }
33252
33253
33254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33255   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33256   bool arg2 ;
33257
33258   arg1 = (Dali::Layer *)jarg1;
33259   arg2 = jarg2 ? true : false;
33260   {
33261     try {
33262       (arg1)->SetTouchConsumed(arg2);
33263     } catch (std::out_of_range& e) {
33264       {
33265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33266       };
33267     } catch (std::exception& e) {
33268       {
33269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33270       };
33271     } catch (...) {
33272       {
33273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33274       };
33275     }
33276   }
33277 }
33278
33279
33280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33281   unsigned int jresult ;
33282   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33283   bool result;
33284
33285   arg1 = (Dali::Layer *)jarg1;
33286   {
33287     try {
33288       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33289     } catch (std::out_of_range& e) {
33290       {
33291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33292       };
33293     } catch (std::exception& e) {
33294       {
33295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33296       };
33297     } catch (...) {
33298       {
33299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33300       };
33301     }
33302   }
33303   jresult = result;
33304   return jresult;
33305 }
33306
33307
33308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33309   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33310   bool arg2 ;
33311
33312   arg1 = (Dali::Layer *)jarg1;
33313   arg2 = jarg2 ? true : false;
33314   {
33315     try {
33316       (arg1)->SetHoverConsumed(arg2);
33317     } catch (std::out_of_range& e) {
33318       {
33319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33320       };
33321     } catch (std::exception& e) {
33322       {
33323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33324       };
33325     } catch (...) {
33326       {
33327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33328       };
33329     }
33330   }
33331 }
33332
33333
33334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33335   unsigned int jresult ;
33336   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33337   bool result;
33338
33339   arg1 = (Dali::Layer *)jarg1;
33340   {
33341     try {
33342       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33343     } catch (std::out_of_range& e) {
33344       {
33345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33346       };
33347     } catch (std::exception& e) {
33348       {
33349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33350       };
33351     } catch (...) {
33352       {
33353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33354       };
33355     }
33356   }
33357   jresult = result;
33358   return jresult;
33359 }
33360
33361
33362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33363   void * jresult ;
33364   Dali::Vector4 *result = 0 ;
33365
33366   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33367   jresult = (void *)result;
33368   return jresult;
33369 }
33370
33371
33372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33373   void * jresult ;
33374   Dali::Vector4 *result = 0 ;
33375
33376   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33377   jresult = (void *)result;
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33383   void * jresult ;
33384   Dali::Stage *result = 0 ;
33385
33386   {
33387     try {
33388       result = (Dali::Stage *)new Dali::Stage();
33389     } catch (std::out_of_range& e) {
33390       {
33391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33392       };
33393     } catch (std::exception& e) {
33394       {
33395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33396       };
33397     } catch (...) {
33398       {
33399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33400       };
33401     }
33402   }
33403   jresult = (void *)result;
33404   return jresult;
33405 }
33406
33407
33408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33409   void * jresult ;
33410   Dali::Stage result;
33411
33412   {
33413     try {
33414       result = Dali::Stage::GetCurrent();
33415     } catch (std::out_of_range& e) {
33416       {
33417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33418       };
33419     } catch (std::exception& e) {
33420       {
33421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33422       };
33423     } catch (...) {
33424       {
33425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33426       };
33427     }
33428   }
33429   jresult = new Dali::Stage((const Dali::Stage &)result);
33430   return jresult;
33431 }
33432
33433
33434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33435   unsigned int jresult ;
33436   bool result;
33437
33438   {
33439     try {
33440       result = (bool)Dali::Stage::IsInstalled();
33441     } catch (std::out_of_range& e) {
33442       {
33443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33444       };
33445     } catch (std::exception& e) {
33446       {
33447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33448       };
33449     } catch (...) {
33450       {
33451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33452       };
33453     }
33454   }
33455   jresult = result;
33456   return jresult;
33457 }
33458
33459
33460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33461   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33462
33463   arg1 = (Dali::Stage *)jarg1;
33464   {
33465     try {
33466       delete arg1;
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_new_Stage__SWIG_1(void * jarg1) {
33485   void * jresult ;
33486   Dali::Stage *arg1 = 0 ;
33487   Dali::Stage *result = 0 ;
33488
33489   arg1 = (Dali::Stage *)jarg1;
33490   if (!arg1) {
33491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33492     return 0;
33493   }
33494   {
33495     try {
33496       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33497     } catch (std::out_of_range& e) {
33498       {
33499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33500       };
33501     } catch (std::exception& e) {
33502       {
33503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33504       };
33505     } catch (...) {
33506       {
33507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33508       };
33509     }
33510   }
33511   jresult = (void *)result;
33512   return jresult;
33513 }
33514
33515
33516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33517   void * jresult ;
33518   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33519   Dali::Stage *arg2 = 0 ;
33520   Dali::Stage *result = 0 ;
33521
33522   arg1 = (Dali::Stage *)jarg1;
33523   arg2 = (Dali::Stage *)jarg2;
33524   if (!arg2) {
33525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33526     return 0;
33527   }
33528   {
33529     try {
33530       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33531     } catch (std::out_of_range& e) {
33532       {
33533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33534       };
33535     } catch (std::exception& e) {
33536       {
33537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33538       };
33539     } catch (...) {
33540       {
33541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33542       };
33543     }
33544   }
33545   jresult = (void *)result;
33546   return jresult;
33547 }
33548
33549
33550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33551   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33552   Dali::Actor *arg2 = 0 ;
33553
33554   arg1 = (Dali::Stage *)jarg1;
33555   arg2 = (Dali::Actor *)jarg2;
33556   if (!arg2) {
33557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33558     return ;
33559   }
33560   {
33561     try {
33562       (arg1)->Add(*arg2);
33563     } catch (std::out_of_range& e) {
33564       {
33565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33566       };
33567     } catch (std::exception& e) {
33568       {
33569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33570       };
33571     } catch (...) {
33572       {
33573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33574       };
33575     }
33576   }
33577 }
33578
33579
33580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33581   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33582   Dali::Actor *arg2 = 0 ;
33583
33584   arg1 = (Dali::Stage *)jarg1;
33585   arg2 = (Dali::Actor *)jarg2;
33586   if (!arg2) {
33587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33588     return ;
33589   }
33590   {
33591     try {
33592       (arg1)->Remove(*arg2);
33593     } catch (std::out_of_range& e) {
33594       {
33595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33596       };
33597     } catch (std::exception& e) {
33598       {
33599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33600       };
33601     } catch (...) {
33602       {
33603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33604       };
33605     }
33606   }
33607 }
33608
33609
33610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33611   void * jresult ;
33612   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33613   Dali::Vector2 result;
33614
33615   arg1 = (Dali::Stage *)jarg1;
33616   {
33617     try {
33618       result = ((Dali::Stage const *)arg1)->GetSize();
33619     } catch (std::out_of_range& e) {
33620       {
33621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (std::exception& e) {
33624       {
33625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33626       };
33627     } catch (...) {
33628       {
33629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33630       };
33631     }
33632   }
33633   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33634   return jresult;
33635 }
33636
33637
33638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33639   void * jresult ;
33640   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33641   Dali::RenderTaskList result;
33642
33643   arg1 = (Dali::Stage *)jarg1;
33644   {
33645     try {
33646       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33647     } catch (std::out_of_range& e) {
33648       {
33649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33650       };
33651     } catch (std::exception& e) {
33652       {
33653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33658       };
33659     }
33660   }
33661   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33662   return jresult;
33663 }
33664
33665
33666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33667   unsigned int jresult ;
33668   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33669   unsigned int result;
33670
33671   arg1 = (Dali::Stage *)jarg1;
33672   {
33673     try {
33674       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33675     } catch (std::out_of_range& e) {
33676       {
33677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33678       };
33679     } catch (std::exception& e) {
33680       {
33681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33682       };
33683     } catch (...) {
33684       {
33685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33686       };
33687     }
33688   }
33689   jresult = result;
33690   return jresult;
33691 }
33692
33693
33694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33695   void * jresult ;
33696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33697   unsigned int arg2 ;
33698   Dali::Layer result;
33699
33700   arg1 = (Dali::Stage *)jarg1;
33701   arg2 = (unsigned int)jarg2;
33702   {
33703     try {
33704       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33705     } catch (std::out_of_range& e) {
33706       {
33707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33708       };
33709     } catch (std::exception& e) {
33710       {
33711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33712       };
33713     } catch (...) {
33714       {
33715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33716       };
33717     }
33718   }
33719   jresult = new Dali::Layer((const Dali::Layer &)result);
33720   return jresult;
33721 }
33722
33723
33724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33725   void * jresult ;
33726   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33727   Dali::Layer result;
33728
33729   arg1 = (Dali::Stage *)jarg1;
33730   {
33731     try {
33732       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33733     } catch (std::out_of_range& e) {
33734       {
33735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33736       };
33737     } catch (std::exception& e) {
33738       {
33739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33740       };
33741     } catch (...) {
33742       {
33743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33744       };
33745     }
33746   }
33747   jresult = new Dali::Layer((const Dali::Layer &)result);
33748   return jresult;
33749 }
33750
33751
33752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33753   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33754   Dali::Vector4 arg2 ;
33755   Dali::Vector4 *argp2 ;
33756
33757   arg1 = (Dali::Stage *)jarg1;
33758   argp2 = (Dali::Vector4 *)jarg2;
33759   if (!argp2) {
33760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33761     return ;
33762   }
33763   arg2 = *argp2;
33764   {
33765     try {
33766       (arg1)->SetBackgroundColor(arg2);
33767     } catch (std::out_of_range& e) {
33768       {
33769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33770       };
33771     } catch (std::exception& e) {
33772       {
33773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33774       };
33775     } catch (...) {
33776       {
33777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33778       };
33779     }
33780   }
33781 }
33782
33783
33784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33785   void * jresult ;
33786   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33787   Dali::Vector4 result;
33788
33789   arg1 = (Dali::Stage *)jarg1;
33790   {
33791     try {
33792       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33793     } catch (std::out_of_range& e) {
33794       {
33795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (std::exception& e) {
33798       {
33799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33800       };
33801     } catch (...) {
33802       {
33803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33804       };
33805     }
33806   }
33807   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33808   return jresult;
33809 }
33810
33811
33812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33813   void * jresult ;
33814   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33815   Dali::Vector2 result;
33816
33817   arg1 = (Dali::Stage *)jarg1;
33818   {
33819     try {
33820       result = ((Dali::Stage const *)arg1)->GetDpi();
33821     } catch (std::out_of_range& e) {
33822       {
33823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (std::exception& e) {
33826       {
33827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33828       };
33829     } catch (...) {
33830       {
33831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33832       };
33833     }
33834   }
33835   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33836   return jresult;
33837 }
33838
33839
33840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33841   void * jresult ;
33842   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33843   Dali::ObjectRegistry result;
33844
33845   arg1 = (Dali::Stage *)jarg1;
33846   {
33847     try {
33848       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33849     } catch (std::out_of_range& e) {
33850       {
33851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33852       };
33853     } catch (std::exception& e) {
33854       {
33855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33856       };
33857     } catch (...) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33860       };
33861     }
33862   }
33863   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33864   return jresult;
33865 }
33866
33867
33868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33869   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33870   float arg2 ;
33871
33872   arg1 = (Dali::Stage *)jarg1;
33873   arg2 = (float)jarg2;
33874   {
33875     try {
33876       (arg1)->KeepRendering(arg2);
33877     } catch (std::out_of_range& e) {
33878       {
33879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33880       };
33881     } catch (std::exception& e) {
33882       {
33883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33884       };
33885     } catch (...) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33888       };
33889     }
33890   }
33891 }
33892
33893
33894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33895   void * jresult ;
33896   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33897   Dali::Stage::KeyEventSignalType *result = 0 ;
33898
33899   arg1 = (Dali::Stage *)jarg1;
33900   {
33901     try {
33902       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33903     } catch (std::out_of_range& e) {
33904       {
33905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33906       };
33907     } catch (std::exception& e) {
33908       {
33909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33910       };
33911     } catch (...) {
33912       {
33913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33914       };
33915     }
33916   }
33917   jresult = (void *)result;
33918   return jresult;
33919 }
33920
33921
33922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33923   void * jresult ;
33924   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33925   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33926
33927   arg1 = (Dali::Stage *)jarg1;
33928   {
33929     try {
33930       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33931     } catch (std::out_of_range& e) {
33932       {
33933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33934       };
33935     } catch (std::exception& e) {
33936       {
33937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33938       };
33939     } catch (...) {
33940       {
33941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33942       };
33943     }
33944   }
33945   jresult = (void *)result;
33946   return jresult;
33947 }
33948
33949
33950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33951   void * jresult ;
33952   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33953   Dali::Stage::TouchSignalType *result = 0 ;
33954
33955   arg1 = (Dali::Stage *)jarg1;
33956   {
33957     try {
33958       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33959     } catch (std::out_of_range& e) {
33960       {
33961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33962       };
33963     } catch (std::exception& e) {
33964       {
33965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33966       };
33967     } catch (...) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33970       };
33971     }
33972   }
33973   jresult = (void *)result;
33974   return jresult;
33975 }
33976
33977
33978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33979   void * jresult ;
33980   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33981   Dali::Stage::WheelEventSignalType *result = 0 ;
33982
33983   arg1 = (Dali::Stage *)jarg1;
33984   {
33985     try {
33986       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33987     } catch (std::out_of_range& e) {
33988       {
33989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33990       };
33991     } catch (std::exception& e) {
33992       {
33993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (...) {
33996       {
33997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33998       };
33999     }
34000   }
34001   jresult = (void *)result;
34002   return jresult;
34003 }
34004
34005
34006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34007   void * jresult ;
34008   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34009   Dali::Stage::ContextStatusSignal *result = 0 ;
34010
34011   arg1 = (Dali::Stage *)jarg1;
34012   {
34013     try {
34014       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (...) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34026       };
34027     }
34028   }
34029   jresult = (void *)result;
34030   return jresult;
34031 }
34032
34033
34034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34035   void * jresult ;
34036   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34037   Dali::Stage::ContextStatusSignal *result = 0 ;
34038
34039   arg1 = (Dali::Stage *)jarg1;
34040   {
34041     try {
34042       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34043     } catch (std::out_of_range& e) {
34044       {
34045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34046       };
34047     } catch (std::exception& e) {
34048       {
34049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34050       };
34051     } catch (...) {
34052       {
34053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34054       };
34055     }
34056   }
34057   jresult = (void *)result;
34058   return jresult;
34059 }
34060
34061
34062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34063   void * jresult ;
34064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34065   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34066
34067   arg1 = (Dali::Stage *)jarg1;
34068   {
34069     try {
34070       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34071     } catch (std::out_of_range& e) {
34072       {
34073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34074       };
34075     } catch (std::exception& e) {
34076       {
34077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34078       };
34079     } catch (...) {
34080       {
34081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34082       };
34083     }
34084   }
34085   jresult = (void *)result;
34086   return jresult;
34087 }
34088
34089
34090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34091   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34092
34093   arg1 = (Dali::RelayoutContainer *)jarg1;
34094   {
34095     try {
34096       delete arg1;
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34104       };
34105     } catch (...) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34108       };
34109     }
34110   }
34111 }
34112
34113
34114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34115   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34116   Dali::Actor *arg2 = 0 ;
34117   Dali::Vector2 *arg3 = 0 ;
34118
34119   arg1 = (Dali::RelayoutContainer *)jarg1;
34120   arg2 = (Dali::Actor *)jarg2;
34121   if (!arg2) {
34122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34123     return ;
34124   }
34125   arg3 = (Dali::Vector2 *)jarg3;
34126   if (!arg3) {
34127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34128     return ;
34129   }
34130   {
34131     try {
34132       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34133     } catch (std::out_of_range& e) {
34134       {
34135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34136       };
34137     } catch (std::exception& e) {
34138       {
34139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34140       };
34141     } catch (...) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34144       };
34145     }
34146   }
34147 }
34148
34149
34150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34151   void * jresult ;
34152   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34153   Dali::CustomActor result;
34154
34155   arg1 = (Dali::CustomActorImpl *)jarg1;
34156   {
34157     try {
34158       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34159     } catch (std::out_of_range& e) {
34160       {
34161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34162       };
34163     } catch (std::exception& e) {
34164       {
34165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34166       };
34167     } catch (...) {
34168       {
34169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34170       };
34171     }
34172   }
34173   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34174   return jresult;
34175 }
34176
34177
34178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34179   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34180   int arg2 ;
34181
34182   arg1 = (Dali::CustomActorImpl *)jarg1;
34183   arg2 = (int)jarg2;
34184   {
34185     try {
34186       (arg1)->OnStageConnection(arg2);
34187     } catch (std::out_of_range& e) {
34188       {
34189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34190       };
34191     } catch (std::exception& e) {
34192       {
34193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34194       };
34195     } catch (...) {
34196       {
34197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34198       };
34199     }
34200   }
34201 }
34202
34203
34204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34205   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34206
34207   arg1 = (Dali::CustomActorImpl *)jarg1;
34208   {
34209     try {
34210       (arg1)->OnStageDisconnection();
34211     } catch (std::out_of_range& e) {
34212       {
34213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34214       };
34215     } catch (std::exception& e) {
34216       {
34217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34218       };
34219     } catch (...) {
34220       {
34221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34222       };
34223     }
34224   }
34225 }
34226
34227
34228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34229   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34230   Dali::Actor *arg2 = 0 ;
34231
34232   arg1 = (Dali::CustomActorImpl *)jarg1;
34233   arg2 = (Dali::Actor *)jarg2;
34234   if (!arg2) {
34235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34236     return ;
34237   }
34238   {
34239     try {
34240       (arg1)->OnChildAdd(*arg2);
34241     } catch (std::out_of_range& e) {
34242       {
34243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34244       };
34245     } catch (std::exception& e) {
34246       {
34247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34252       };
34253     }
34254   }
34255 }
34256
34257
34258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34260   Dali::Actor *arg2 = 0 ;
34261
34262   arg1 = (Dali::CustomActorImpl *)jarg1;
34263   arg2 = (Dali::Actor *)jarg2;
34264   if (!arg2) {
34265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34266     return ;
34267   }
34268   {
34269     try {
34270       (arg1)->OnChildRemove(*arg2);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285 }
34286
34287
34288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34289   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34290   Dali::Property::Index arg2 ;
34291   Dali::Property::Value arg3 ;
34292   Dali::Property::Value *argp3 ;
34293
34294   arg1 = (Dali::CustomActorImpl *)jarg1;
34295   arg2 = (Dali::Property::Index)jarg2;
34296   argp3 = (Dali::Property::Value *)jarg3;
34297   if (!argp3) {
34298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34299     return ;
34300   }
34301   arg3 = *argp3;
34302   {
34303     try {
34304       (arg1)->OnPropertySet(arg2,arg3);
34305     } catch (std::out_of_range& e) {
34306       {
34307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34308       };
34309     } catch (std::exception& e) {
34310       {
34311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34312       };
34313     } catch (...) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34316       };
34317     }
34318   }
34319 }
34320
34321
34322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34323   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34324   Dali::Vector3 *arg2 = 0 ;
34325
34326   arg1 = (Dali::CustomActorImpl *)jarg1;
34327   arg2 = (Dali::Vector3 *)jarg2;
34328   if (!arg2) {
34329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34330     return ;
34331   }
34332   {
34333     try {
34334       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34335     } catch (std::out_of_range& e) {
34336       {
34337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34338       };
34339     } catch (std::exception& e) {
34340       {
34341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34342       };
34343     } catch (...) {
34344       {
34345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34346       };
34347     }
34348   }
34349 }
34350
34351
34352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34353   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34354   Dali::Animation *arg2 = 0 ;
34355   Dali::Vector3 *arg3 = 0 ;
34356
34357   arg1 = (Dali::CustomActorImpl *)jarg1;
34358   arg2 = (Dali::Animation *)jarg2;
34359   if (!arg2) {
34360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34361     return ;
34362   }
34363   arg3 = (Dali::Vector3 *)jarg3;
34364   if (!arg3) {
34365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34366     return ;
34367   }
34368   {
34369     try {
34370       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34371     } catch (std::out_of_range& e) {
34372       {
34373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34374       };
34375     } catch (std::exception& e) {
34376       {
34377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34378       };
34379     } catch (...) {
34380       {
34381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34382       };
34383     }
34384   }
34385 }
34386
34387
34388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34389   unsigned int jresult ;
34390   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34391   Dali::TouchEvent *arg2 = 0 ;
34392   bool result;
34393
34394   arg1 = (Dali::CustomActorImpl *)jarg1;
34395   arg2 = (Dali::TouchEvent *)jarg2;
34396   if (!arg2) {
34397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34398     return 0;
34399   }
34400   {
34401     try {
34402       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34403     } catch (std::out_of_range& e) {
34404       {
34405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34406       };
34407     } catch (std::exception& e) {
34408       {
34409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34410       };
34411     } catch (...) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34414       };
34415     }
34416   }
34417   jresult = result;
34418   return jresult;
34419 }
34420
34421
34422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34423   unsigned int jresult ;
34424   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34425   Dali::HoverEvent *arg2 = 0 ;
34426   bool result;
34427
34428   arg1 = (Dali::CustomActorImpl *)jarg1;
34429   arg2 = (Dali::HoverEvent *)jarg2;
34430   if (!arg2) {
34431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34432     return 0;
34433   }
34434   {
34435     try {
34436       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34437     } catch (std::out_of_range& e) {
34438       {
34439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (std::exception& e) {
34442       {
34443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34444       };
34445     } catch (...) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34448       };
34449     }
34450   }
34451   jresult = result;
34452   return jresult;
34453 }
34454
34455
34456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34457   unsigned int jresult ;
34458   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34459   Dali::KeyEvent *arg2 = 0 ;
34460   bool result;
34461
34462   arg1 = (Dali::CustomActorImpl *)jarg1;
34463   arg2 = (Dali::KeyEvent *)jarg2;
34464   if (!arg2) {
34465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34466     return 0;
34467   }
34468   {
34469     try {
34470       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34471     } catch (std::out_of_range& e) {
34472       {
34473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34474       };
34475     } catch (std::exception& e) {
34476       {
34477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34478       };
34479     } catch (...) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34482       };
34483     }
34484   }
34485   jresult = result;
34486   return jresult;
34487 }
34488
34489
34490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34491   unsigned int jresult ;
34492   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34493   Dali::WheelEvent *arg2 = 0 ;
34494   bool result;
34495
34496   arg1 = (Dali::CustomActorImpl *)jarg1;
34497   arg2 = (Dali::WheelEvent *)jarg2;
34498   if (!arg2) {
34499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34500     return 0;
34501   }
34502   {
34503     try {
34504       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34512       };
34513     } catch (...) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34516       };
34517     }
34518   }
34519   jresult = result;
34520   return jresult;
34521 }
34522
34523
34524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34525   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34526   Dali::Vector2 *arg2 = 0 ;
34527   Dali::RelayoutContainer *arg3 = 0 ;
34528
34529   arg1 = (Dali::CustomActorImpl *)jarg1;
34530   arg2 = (Dali::Vector2 *)jarg2;
34531   if (!arg2) {
34532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34533     return ;
34534   }
34535   arg3 = (Dali::RelayoutContainer *)jarg3;
34536   if (!arg3) {
34537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34538     return ;
34539   }
34540   {
34541     try {
34542       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34543     } catch (std::out_of_range& e) {
34544       {
34545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34546       };
34547     } catch (std::exception& e) {
34548       {
34549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34550       };
34551     } catch (...) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34554       };
34555     }
34556   }
34557 }
34558
34559
34560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34561   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34562   Dali::ResizePolicy::Type arg2 ;
34563   Dali::Dimension::Type arg3 ;
34564
34565   arg1 = (Dali::CustomActorImpl *)jarg1;
34566   arg2 = (Dali::ResizePolicy::Type)jarg2;
34567   arg3 = (Dali::Dimension::Type)jarg3;
34568   {
34569     try {
34570       (arg1)->OnSetResizePolicy(arg2,arg3);
34571     } catch (std::out_of_range& e) {
34572       {
34573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34574       };
34575     } catch (std::exception& e) {
34576       {
34577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (...) {
34580       {
34581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34582       };
34583     }
34584   }
34585 }
34586
34587
34588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34589   void * jresult ;
34590   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34591   Dali::Vector3 result;
34592
34593   arg1 = (Dali::CustomActorImpl *)jarg1;
34594   {
34595     try {
34596       result = (arg1)->GetNaturalSize();
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 = new Dali::Vector3((const Dali::Vector3 &)result);
34612   return jresult;
34613 }
34614
34615
34616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34617   float jresult ;
34618   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34619   Dali::Actor *arg2 = 0 ;
34620   Dali::Dimension::Type arg3 ;
34621   float result;
34622
34623   arg1 = (Dali::CustomActorImpl *)jarg1;
34624   arg2 = (Dali::Actor *)jarg2;
34625   if (!arg2) {
34626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34627     return 0;
34628   }
34629   arg3 = (Dali::Dimension::Type)jarg3;
34630   {
34631     try {
34632       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34633     } catch (std::out_of_range& e) {
34634       {
34635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34636       };
34637     } catch (std::exception& e) {
34638       {
34639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34640       };
34641     } catch (...) {
34642       {
34643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34644       };
34645     }
34646   }
34647   jresult = result;
34648   return jresult;
34649 }
34650
34651
34652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34653   float jresult ;
34654   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34655   float arg2 ;
34656   float result;
34657
34658   arg1 = (Dali::CustomActorImpl *)jarg1;
34659   arg2 = (float)jarg2;
34660   {
34661     try {
34662       result = (float)(arg1)->GetHeightForWidth(arg2);
34663     } catch (std::out_of_range& e) {
34664       {
34665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34666       };
34667     } catch (std::exception& e) {
34668       {
34669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34670       };
34671     } catch (...) {
34672       {
34673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34674       };
34675     }
34676   }
34677   jresult = result;
34678   return jresult;
34679 }
34680
34681
34682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34683   float jresult ;
34684   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34685   float arg2 ;
34686   float result;
34687
34688   arg1 = (Dali::CustomActorImpl *)jarg1;
34689   arg2 = (float)jarg2;
34690   {
34691     try {
34692       result = (float)(arg1)->GetWidthForHeight(arg2);
34693     } catch (std::out_of_range& e) {
34694       {
34695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34696       };
34697     } catch (std::exception& e) {
34698       {
34699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34700       };
34701     } catch (...) {
34702       {
34703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34704       };
34705     }
34706   }
34707   jresult = result;
34708   return jresult;
34709 }
34710
34711
34712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34713   unsigned int jresult ;
34714   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34715   Dali::Dimension::Type arg2 ;
34716   bool result;
34717
34718   arg1 = (Dali::CustomActorImpl *)jarg1;
34719   arg2 = (Dali::Dimension::Type)jarg2;
34720   {
34721     try {
34722       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34723     } catch (std::out_of_range& e) {
34724       {
34725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34726       };
34727     } catch (std::exception& e) {
34728       {
34729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34730       };
34731     } catch (...) {
34732       {
34733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34734       };
34735     }
34736   }
34737   jresult = result;
34738   return jresult;
34739 }
34740
34741
34742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34743   unsigned int jresult ;
34744   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34745   bool result;
34746
34747   arg1 = (Dali::CustomActorImpl *)jarg1;
34748   {
34749     try {
34750       result = (bool)(arg1)->RelayoutDependentOnChildren();
34751     } catch (std::out_of_range& e) {
34752       {
34753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34754       };
34755     } catch (std::exception& e) {
34756       {
34757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34758       };
34759     } catch (...) {
34760       {
34761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34762       };
34763     }
34764   }
34765   jresult = result;
34766   return jresult;
34767 }
34768
34769
34770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34771   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34772   Dali::Dimension::Type arg2 ;
34773
34774   arg1 = (Dali::CustomActorImpl *)jarg1;
34775   arg2 = (Dali::Dimension::Type)jarg2;
34776   {
34777     try {
34778       (arg1)->OnCalculateRelayoutSize(arg2);
34779     } catch (std::out_of_range& e) {
34780       {
34781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34782       };
34783     } catch (std::exception& e) {
34784       {
34785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34786       };
34787     } catch (...) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34790       };
34791     }
34792   }
34793 }
34794
34795
34796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34797   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34798   float arg2 ;
34799   Dali::Dimension::Type arg3 ;
34800
34801   arg1 = (Dali::CustomActorImpl *)jarg1;
34802   arg2 = (float)jarg2;
34803   arg3 = (Dali::Dimension::Type)jarg3;
34804   {
34805     try {
34806       (arg1)->OnLayoutNegotiated(arg2,arg3);
34807     } catch (std::out_of_range& e) {
34808       {
34809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34810       };
34811     } catch (std::exception& e) {
34812       {
34813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34818       };
34819     }
34820   }
34821 }
34822
34823
34824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34825   unsigned int jresult ;
34826   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34827   bool result;
34828
34829   arg1 = (Dali::CustomActorImpl *)jarg1;
34830   {
34831     try {
34832       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34833     } catch (std::out_of_range& e) {
34834       {
34835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34836       };
34837     } catch (std::exception& e) {
34838       {
34839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34840       };
34841     } catch (...) {
34842       {
34843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34844       };
34845     }
34846   }
34847   jresult = result;
34848   return jresult;
34849 }
34850
34851
34852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34853   unsigned int jresult ;
34854   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34855   bool result;
34856
34857   arg1 = (Dali::CustomActorImpl *)jarg1;
34858   {
34859     try {
34860       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34861     } catch (std::out_of_range& e) {
34862       {
34863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34864       };
34865     } catch (std::exception& e) {
34866       {
34867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34868       };
34869     } catch (...) {
34870       {
34871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34872       };
34873     }
34874   }
34875   jresult = result;
34876   return jresult;
34877 }
34878
34879
34880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34881   unsigned int jresult ;
34882   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34883   bool result;
34884
34885   arg1 = (Dali::CustomActorImpl *)jarg1;
34886   {
34887     try {
34888       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34889     } catch (std::out_of_range& e) {
34890       {
34891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34892       };
34893     } catch (std::exception& e) {
34894       {
34895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34896       };
34897     } catch (...) {
34898       {
34899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34900       };
34901     }
34902   }
34903   jresult = result;
34904   return jresult;
34905 }
34906
34907
34908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34909   unsigned int jresult ;
34910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34911   bool result;
34912
34913   arg1 = (Dali::CustomActorImpl *)jarg1;
34914   {
34915     try {
34916       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34917     } catch (std::out_of_range& e) {
34918       {
34919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34920       };
34921     } catch (std::exception& e) {
34922       {
34923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34924       };
34925     } catch (...) {
34926       {
34927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34928       };
34929     }
34930   }
34931   jresult = result;
34932   return jresult;
34933 }
34934
34935
34936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34937   void * jresult ;
34938   Dali::CustomActor *result = 0 ;
34939
34940   {
34941     try {
34942       result = (Dali::CustomActor *)new Dali::CustomActor();
34943     } catch (std::out_of_range& e) {
34944       {
34945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34946       };
34947     } catch (std::exception& e) {
34948       {
34949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34950       };
34951     } catch (...) {
34952       {
34953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34954       };
34955     }
34956   }
34957   jresult = (void *)result;
34958   return jresult;
34959 }
34960
34961
34962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34963   void * jresult ;
34964   Dali::BaseHandle arg1 ;
34965   Dali::BaseHandle *argp1 ;
34966   Dali::CustomActor result;
34967
34968   argp1 = (Dali::BaseHandle *)jarg1;
34969   if (!argp1) {
34970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34971     return 0;
34972   }
34973   arg1 = *argp1;
34974   {
34975     try {
34976       result = Dali::CustomActor::DownCast(arg1);
34977     } catch (std::out_of_range& e) {
34978       {
34979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34980       };
34981     } catch (std::exception& e) {
34982       {
34983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34984       };
34985     } catch (...) {
34986       {
34987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34988       };
34989     }
34990   }
34991   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34992   return jresult;
34993 }
34994
34995
34996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34997   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34998
34999   arg1 = (Dali::CustomActor *)jarg1;
35000   {
35001     try {
35002       delete arg1;
35003     } catch (std::out_of_range& e) {
35004       {
35005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35006       };
35007     } catch (std::exception& e) {
35008       {
35009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35010       };
35011     } catch (...) {
35012       {
35013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35014       };
35015     }
35016   }
35017 }
35018
35019
35020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35021   void * jresult ;
35022   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35023   Dali::CustomActorImpl *result = 0 ;
35024
35025   arg1 = (Dali::CustomActor *)jarg1;
35026   {
35027     try {
35028       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35029     } catch (std::out_of_range& e) {
35030       {
35031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35032       };
35033     } catch (std::exception& e) {
35034       {
35035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35036       };
35037     } catch (...) {
35038       {
35039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35040       };
35041     }
35042   }
35043   jresult = (void *)result;
35044   return jresult;
35045 }
35046
35047
35048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35049   void * jresult ;
35050   Dali::CustomActorImpl *arg1 = 0 ;
35051   Dali::CustomActor *result = 0 ;
35052
35053   arg1 = (Dali::CustomActorImpl *)jarg1;
35054   if (!arg1) {
35055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35056     return 0;
35057   }
35058   {
35059     try {
35060       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35061     } catch (std::out_of_range& e) {
35062       {
35063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35064       };
35065     } catch (std::exception& e) {
35066       {
35067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35068       };
35069     } catch (...) {
35070       {
35071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35072       };
35073     }
35074   }
35075   jresult = (void *)result;
35076   return jresult;
35077 }
35078
35079
35080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35081   void * jresult ;
35082   Dali::CustomActor *arg1 = 0 ;
35083   Dali::CustomActor *result = 0 ;
35084
35085   arg1 = (Dali::CustomActor *)jarg1;
35086   if (!arg1) {
35087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35088     return 0;
35089   }
35090   {
35091     try {
35092       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35093     } catch (std::out_of_range& e) {
35094       {
35095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35096       };
35097     } catch (std::exception& e) {
35098       {
35099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35100       };
35101     } catch (...) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35104       };
35105     }
35106   }
35107   jresult = (void *)result;
35108   return jresult;
35109 }
35110
35111
35112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35113   void * jresult ;
35114   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35115   Dali::CustomActor *arg2 = 0 ;
35116   Dali::CustomActor *result = 0 ;
35117
35118   arg1 = (Dali::CustomActor *)jarg1;
35119   arg2 = (Dali::CustomActor *)jarg2;
35120   if (!arg2) {
35121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35122     return 0;
35123   }
35124   {
35125     try {
35126       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
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 int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35147   int jresult ;
35148   int result;
35149
35150   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35151   jresult = (int)result;
35152   return jresult;
35153 }
35154
35155
35156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35157   int jresult ;
35158   int result;
35159
35160   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35161   jresult = (int)result;
35162   return jresult;
35163 }
35164
35165
35166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35167   int jresult ;
35168   int result;
35169
35170   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35171   jresult = (int)result;
35172   return jresult;
35173 }
35174
35175
35176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35177   int jresult ;
35178   int result;
35179
35180   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35181   jresult = (int)result;
35182   return jresult;
35183 }
35184
35185
35186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35187   int jresult ;
35188   int result;
35189
35190   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35191   jresult = (int)result;
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35197   int jresult ;
35198   int result;
35199
35200   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35201   jresult = (int)result;
35202   return jresult;
35203 }
35204
35205
35206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35207   int jresult ;
35208   int result;
35209
35210   result = (int)Dali::PanGestureDetector::Property::PANNING;
35211   jresult = (int)result;
35212   return jresult;
35213 }
35214
35215
35216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35217   void * jresult ;
35218   Dali::PanGestureDetector::Property *result = 0 ;
35219
35220   {
35221     try {
35222       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35223     } catch (std::out_of_range& e) {
35224       {
35225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35226       };
35227     } catch (std::exception& e) {
35228       {
35229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35230       };
35231     } catch (...) {
35232       {
35233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35234       };
35235     }
35236   }
35237   jresult = (void *)result;
35238   return jresult;
35239 }
35240
35241
35242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35243   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35244
35245   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35246   {
35247     try {
35248       delete arg1;
35249     } catch (std::out_of_range& e) {
35250       {
35251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35252       };
35253     } catch (std::exception& e) {
35254       {
35255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35256       };
35257     } catch (...) {
35258       {
35259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35260       };
35261     }
35262   }
35263 }
35264
35265
35266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35267   void * jresult ;
35268   Dali::Radian *result = 0 ;
35269
35270   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35271   jresult = (void *)result;
35272   return jresult;
35273 }
35274
35275
35276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35277   void * jresult ;
35278   Dali::Radian *result = 0 ;
35279
35280   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35281   jresult = (void *)result;
35282   return jresult;
35283 }
35284
35285
35286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35287   void * jresult ;
35288   Dali::Radian *result = 0 ;
35289
35290   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35291   jresult = (void *)result;
35292   return jresult;
35293 }
35294
35295
35296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35297   void * jresult ;
35298   Dali::Radian *result = 0 ;
35299
35300   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35301   jresult = (void *)result;
35302   return jresult;
35303 }
35304
35305
35306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35307   void * jresult ;
35308   Dali::Radian *result = 0 ;
35309
35310   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35311   jresult = (void *)result;
35312   return jresult;
35313 }
35314
35315
35316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35317   void * jresult ;
35318   Dali::Radian *result = 0 ;
35319
35320   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35321   jresult = (void *)result;
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35327   void * jresult ;
35328   Dali::Radian *result = 0 ;
35329
35330   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35331   jresult = (void *)result;
35332   return jresult;
35333 }
35334
35335
35336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35337   void * jresult ;
35338   Dali::PanGestureDetector *result = 0 ;
35339
35340   {
35341     try {
35342       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35343     } catch (std::out_of_range& e) {
35344       {
35345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35346       };
35347     } catch (std::exception& e) {
35348       {
35349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35350       };
35351     } catch (...) {
35352       {
35353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35354       };
35355     }
35356   }
35357   jresult = (void *)result;
35358   return jresult;
35359 }
35360
35361
35362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35363   void * jresult ;
35364   Dali::PanGestureDetector result;
35365
35366   {
35367     try {
35368       result = Dali::PanGestureDetector::New();
35369     } catch (std::out_of_range& e) {
35370       {
35371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35372       };
35373     } catch (std::exception& e) {
35374       {
35375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35376       };
35377     } catch (...) {
35378       {
35379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35380       };
35381     }
35382   }
35383   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35384   return jresult;
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35389   void * jresult ;
35390   Dali::BaseHandle arg1 ;
35391   Dali::BaseHandle *argp1 ;
35392   Dali::PanGestureDetector result;
35393
35394   argp1 = (Dali::BaseHandle *)jarg1;
35395   if (!argp1) {
35396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35397     return 0;
35398   }
35399   arg1 = *argp1;
35400   {
35401     try {
35402       result = Dali::PanGestureDetector::DownCast(arg1);
35403     } catch (std::out_of_range& e) {
35404       {
35405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35406       };
35407     } catch (std::exception& e) {
35408       {
35409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35410       };
35411     } catch (...) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35414       };
35415     }
35416   }
35417   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35418   return jresult;
35419 }
35420
35421
35422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35423   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35424
35425   arg1 = (Dali::PanGestureDetector *)jarg1;
35426   {
35427     try {
35428       delete arg1;
35429     } catch (std::out_of_range& e) {
35430       {
35431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35432       };
35433     } catch (std::exception& e) {
35434       {
35435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35436       };
35437     } catch (...) {
35438       {
35439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35440       };
35441     }
35442   }
35443 }
35444
35445
35446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35447   void * jresult ;
35448   Dali::PanGestureDetector *arg1 = 0 ;
35449   Dali::PanGestureDetector *result = 0 ;
35450
35451   arg1 = (Dali::PanGestureDetector *)jarg1;
35452   if (!arg1) {
35453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35454     return 0;
35455   }
35456   {
35457     try {
35458       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35459     } catch (std::out_of_range& e) {
35460       {
35461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35462       };
35463     } catch (std::exception& e) {
35464       {
35465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35466       };
35467     } catch (...) {
35468       {
35469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35470       };
35471     }
35472   }
35473   jresult = (void *)result;
35474   return jresult;
35475 }
35476
35477
35478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35479   void * jresult ;
35480   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35481   Dali::PanGestureDetector *arg2 = 0 ;
35482   Dali::PanGestureDetector *result = 0 ;
35483
35484   arg1 = (Dali::PanGestureDetector *)jarg1;
35485   arg2 = (Dali::PanGestureDetector *)jarg2;
35486   if (!arg2) {
35487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35488     return 0;
35489   }
35490   {
35491     try {
35492       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35493     } catch (std::out_of_range& e) {
35494       {
35495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35496       };
35497     } catch (std::exception& e) {
35498       {
35499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35500       };
35501     } catch (...) {
35502       {
35503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35504       };
35505     }
35506   }
35507   jresult = (void *)result;
35508   return jresult;
35509 }
35510
35511
35512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35513   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35514   unsigned int arg2 ;
35515
35516   arg1 = (Dali::PanGestureDetector *)jarg1;
35517   arg2 = (unsigned int)jarg2;
35518   {
35519     try {
35520       (arg1)->SetMinimumTouchesRequired(arg2);
35521     } catch (std::out_of_range& e) {
35522       {
35523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35524       };
35525     } catch (std::exception& e) {
35526       {
35527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35528       };
35529     } catch (...) {
35530       {
35531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35532       };
35533     }
35534   }
35535 }
35536
35537
35538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35539   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35540   unsigned int arg2 ;
35541
35542   arg1 = (Dali::PanGestureDetector *)jarg1;
35543   arg2 = (unsigned int)jarg2;
35544   {
35545     try {
35546       (arg1)->SetMaximumTouchesRequired(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35565   unsigned int jresult ;
35566   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35567   unsigned int result;
35568
35569   arg1 = (Dali::PanGestureDetector *)jarg1;
35570   {
35571     try {
35572       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35573     } catch (std::out_of_range& e) {
35574       {
35575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35576       };
35577     } catch (std::exception& e) {
35578       {
35579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35580       };
35581     } catch (...) {
35582       {
35583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35584       };
35585     }
35586   }
35587   jresult = result;
35588   return jresult;
35589 }
35590
35591
35592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35593   unsigned int jresult ;
35594   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35595   unsigned int result;
35596
35597   arg1 = (Dali::PanGestureDetector *)jarg1;
35598   {
35599     try {
35600       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35601     } catch (std::out_of_range& e) {
35602       {
35603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35604       };
35605     } catch (std::exception& e) {
35606       {
35607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35608       };
35609     } catch (...) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35612       };
35613     }
35614   }
35615   jresult = result;
35616   return jresult;
35617 }
35618
35619
35620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35621   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35622   Dali::Radian arg2 ;
35623   Dali::Radian arg3 ;
35624   Dali::Radian *argp2 ;
35625   Dali::Radian *argp3 ;
35626
35627   arg1 = (Dali::PanGestureDetector *)jarg1;
35628   argp2 = (Dali::Radian *)jarg2;
35629   if (!argp2) {
35630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35631     return ;
35632   }
35633   arg2 = *argp2;
35634   argp3 = (Dali::Radian *)jarg3;
35635   if (!argp3) {
35636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35637     return ;
35638   }
35639   arg3 = *argp3;
35640   {
35641     try {
35642       (arg1)->AddAngle(arg2,arg3);
35643     } catch (std::out_of_range& e) {
35644       {
35645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35646       };
35647     } catch (std::exception& e) {
35648       {
35649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35650       };
35651     } catch (...) {
35652       {
35653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35654       };
35655     }
35656   }
35657 }
35658
35659
35660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35661   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35662   Dali::Radian arg2 ;
35663   Dali::Radian *argp2 ;
35664
35665   arg1 = (Dali::PanGestureDetector *)jarg1;
35666   argp2 = (Dali::Radian *)jarg2;
35667   if (!argp2) {
35668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35669     return ;
35670   }
35671   arg2 = *argp2;
35672   {
35673     try {
35674       (arg1)->AddAngle(arg2);
35675     } catch (std::out_of_range& e) {
35676       {
35677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35678       };
35679     } catch (std::exception& e) {
35680       {
35681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35682       };
35683     } catch (...) {
35684       {
35685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35686       };
35687     }
35688   }
35689 }
35690
35691
35692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35693   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35694   Dali::Radian arg2 ;
35695   Dali::Radian arg3 ;
35696   Dali::Radian *argp2 ;
35697   Dali::Radian *argp3 ;
35698
35699   arg1 = (Dali::PanGestureDetector *)jarg1;
35700   argp2 = (Dali::Radian *)jarg2;
35701   if (!argp2) {
35702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35703     return ;
35704   }
35705   arg2 = *argp2;
35706   argp3 = (Dali::Radian *)jarg3;
35707   if (!argp3) {
35708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35709     return ;
35710   }
35711   arg3 = *argp3;
35712   {
35713     try {
35714       (arg1)->AddDirection(arg2,arg3);
35715     } catch (std::out_of_range& e) {
35716       {
35717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35718       };
35719     } catch (std::exception& e) {
35720       {
35721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35722       };
35723     } catch (...) {
35724       {
35725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35726       };
35727     }
35728   }
35729 }
35730
35731
35732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35733   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35734   Dali::Radian arg2 ;
35735   Dali::Radian *argp2 ;
35736
35737   arg1 = (Dali::PanGestureDetector *)jarg1;
35738   argp2 = (Dali::Radian *)jarg2;
35739   if (!argp2) {
35740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35741     return ;
35742   }
35743   arg2 = *argp2;
35744   {
35745     try {
35746       (arg1)->AddDirection(arg2);
35747     } catch (std::out_of_range& e) {
35748       {
35749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35750       };
35751     } catch (std::exception& e) {
35752       {
35753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35754       };
35755     } catch (...) {
35756       {
35757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35758       };
35759     }
35760   }
35761 }
35762
35763
35764 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35765   unsigned long jresult ;
35766   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35767   size_t result;
35768
35769   arg1 = (Dali::PanGestureDetector *)jarg1;
35770   {
35771     try {
35772       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35773     } catch (std::out_of_range& e) {
35774       {
35775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35776       };
35777     } catch (std::exception& e) {
35778       {
35779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35780       };
35781     } catch (...) {
35782       {
35783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35784       };
35785     }
35786   }
35787   jresult = (unsigned long)result;
35788   return jresult;
35789 }
35790
35791
35792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35793   void * jresult ;
35794   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35795   size_t arg2 ;
35796   Dali::PanGestureDetector::AngleThresholdPair result;
35797
35798   arg1 = (Dali::PanGestureDetector *)jarg1;
35799   arg2 = (size_t)jarg2;
35800   {
35801     try {
35802       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35803     } catch (std::out_of_range& e) {
35804       {
35805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35806       };
35807     } catch (std::exception& e) {
35808       {
35809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35810       };
35811     } catch (...) {
35812       {
35813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35814       };
35815     }
35816   }
35817   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35818   return jresult;
35819 }
35820
35821
35822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35823   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35824
35825   arg1 = (Dali::PanGestureDetector *)jarg1;
35826   {
35827     try {
35828       (arg1)->ClearAngles();
35829     } catch (std::out_of_range& e) {
35830       {
35831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35832       };
35833     } catch (std::exception& e) {
35834       {
35835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35836       };
35837     } catch (...) {
35838       {
35839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35840       };
35841     }
35842   }
35843 }
35844
35845
35846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35847   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35848   Dali::Radian arg2 ;
35849   Dali::Radian *argp2 ;
35850
35851   arg1 = (Dali::PanGestureDetector *)jarg1;
35852   argp2 = (Dali::Radian *)jarg2;
35853   if (!argp2) {
35854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35855     return ;
35856   }
35857   arg2 = *argp2;
35858   {
35859     try {
35860       (arg1)->RemoveAngle(arg2);
35861     } catch (std::out_of_range& e) {
35862       {
35863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35864       };
35865     } catch (std::exception& e) {
35866       {
35867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35868       };
35869     } catch (...) {
35870       {
35871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35872       };
35873     }
35874   }
35875 }
35876
35877
35878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35879   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35880   Dali::Radian arg2 ;
35881   Dali::Radian *argp2 ;
35882
35883   arg1 = (Dali::PanGestureDetector *)jarg1;
35884   argp2 = (Dali::Radian *)jarg2;
35885   if (!argp2) {
35886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35887     return ;
35888   }
35889   arg2 = *argp2;
35890   {
35891     try {
35892       (arg1)->RemoveDirection(arg2);
35893     } catch (std::out_of_range& e) {
35894       {
35895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35896       };
35897     } catch (std::exception& e) {
35898       {
35899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35900       };
35901     } catch (...) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35904       };
35905     }
35906   }
35907 }
35908
35909
35910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35911   void * jresult ;
35912   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35913   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35914
35915   arg1 = (Dali::PanGestureDetector *)jarg1;
35916   {
35917     try {
35918       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35919     } catch (std::out_of_range& e) {
35920       {
35921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35922       };
35923     } catch (std::exception& e) {
35924       {
35925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35926       };
35927     } catch (...) {
35928       {
35929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35930       };
35931     }
35932   }
35933   jresult = (void *)result;
35934   return jresult;
35935 }
35936
35937
35938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35939   Dali::PanGesture *arg1 = 0 ;
35940
35941   arg1 = (Dali::PanGesture *)jarg1;
35942   if (!arg1) {
35943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35944     return ;
35945   }
35946   {
35947     try {
35948       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35949     } catch (std::out_of_range& e) {
35950       {
35951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (std::exception& e) {
35954       {
35955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35960       };
35961     }
35962   }
35963 }
35964
35965
35966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35967   void * jresult ;
35968   Dali::PanGesture *result = 0 ;
35969
35970   {
35971     try {
35972       result = (Dali::PanGesture *)new Dali::PanGesture();
35973     } catch (std::out_of_range& e) {
35974       {
35975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35976       };
35977     } catch (std::exception& e) {
35978       {
35979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35980       };
35981     } catch (...) {
35982       {
35983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35984       };
35985     }
35986   }
35987   jresult = (void *)result;
35988   return jresult;
35989 }
35990
35991
35992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35993   void * jresult ;
35994   Dali::Gesture::State arg1 ;
35995   Dali::PanGesture *result = 0 ;
35996
35997   arg1 = (Dali::Gesture::State)jarg1;
35998   {
35999     try {
36000       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36001     } catch (std::out_of_range& e) {
36002       {
36003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36004       };
36005     } catch (std::exception& e) {
36006       {
36007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36008       };
36009     } catch (...) {
36010       {
36011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36012       };
36013     }
36014   }
36015   jresult = (void *)result;
36016   return jresult;
36017 }
36018
36019
36020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36021   void * jresult ;
36022   Dali::PanGesture *arg1 = 0 ;
36023   Dali::PanGesture *result = 0 ;
36024
36025   arg1 = (Dali::PanGesture *)jarg1;
36026   if (!arg1) {
36027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36028     return 0;
36029   }
36030   {
36031     try {
36032       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36033     } catch (std::out_of_range& e) {
36034       {
36035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36036       };
36037     } catch (std::exception& e) {
36038       {
36039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36044       };
36045     }
36046   }
36047   jresult = (void *)result;
36048   return jresult;
36049 }
36050
36051
36052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36053   void * jresult ;
36054   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36055   Dali::PanGesture *arg2 = 0 ;
36056   Dali::PanGesture *result = 0 ;
36057
36058   arg1 = (Dali::PanGesture *)jarg1;
36059   arg2 = (Dali::PanGesture *)jarg2;
36060   if (!arg2) {
36061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36062     return 0;
36063   }
36064   {
36065     try {
36066       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36067     } catch (std::out_of_range& e) {
36068       {
36069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36070       };
36071     } catch (std::exception& e) {
36072       {
36073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36074       };
36075     } catch (...) {
36076       {
36077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36078       };
36079     }
36080   }
36081   jresult = (void *)result;
36082   return jresult;
36083 }
36084
36085
36086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36087   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36088
36089   arg1 = (Dali::PanGesture *)jarg1;
36090   {
36091     try {
36092       delete arg1;
36093     } catch (std::out_of_range& e) {
36094       {
36095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36096       };
36097     } catch (std::exception& e) {
36098       {
36099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36100       };
36101     } catch (...) {
36102       {
36103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36104       };
36105     }
36106   }
36107 }
36108
36109
36110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36111   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36112   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36113
36114   arg1 = (Dali::PanGesture *)jarg1;
36115   arg2 = (Dali::Vector2 *)jarg2;
36116   if (arg1) (arg1)->velocity = *arg2;
36117 }
36118
36119
36120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36121   void * jresult ;
36122   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36123   Dali::Vector2 *result = 0 ;
36124
36125   arg1 = (Dali::PanGesture *)jarg1;
36126   result = (Dali::Vector2 *)& ((arg1)->velocity);
36127   jresult = (void *)result;
36128   return jresult;
36129 }
36130
36131
36132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36133   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36134   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36135
36136   arg1 = (Dali::PanGesture *)jarg1;
36137   arg2 = (Dali::Vector2 *)jarg2;
36138   if (arg1) (arg1)->displacement = *arg2;
36139 }
36140
36141
36142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36143   void * jresult ;
36144   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36145   Dali::Vector2 *result = 0 ;
36146
36147   arg1 = (Dali::PanGesture *)jarg1;
36148   result = (Dali::Vector2 *)& ((arg1)->displacement);
36149   jresult = (void *)result;
36150   return jresult;
36151 }
36152
36153
36154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36155   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36156   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36157
36158   arg1 = (Dali::PanGesture *)jarg1;
36159   arg2 = (Dali::Vector2 *)jarg2;
36160   if (arg1) (arg1)->position = *arg2;
36161 }
36162
36163
36164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36165   void * jresult ;
36166   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36167   Dali::Vector2 *result = 0 ;
36168
36169   arg1 = (Dali::PanGesture *)jarg1;
36170   result = (Dali::Vector2 *)& ((arg1)->position);
36171   jresult = (void *)result;
36172   return jresult;
36173 }
36174
36175
36176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36177   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36178   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36179
36180   arg1 = (Dali::PanGesture *)jarg1;
36181   arg2 = (Dali::Vector2 *)jarg2;
36182   if (arg1) (arg1)->screenVelocity = *arg2;
36183 }
36184
36185
36186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36187   void * jresult ;
36188   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36189   Dali::Vector2 *result = 0 ;
36190
36191   arg1 = (Dali::PanGesture *)jarg1;
36192   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36193   jresult = (void *)result;
36194   return jresult;
36195 }
36196
36197
36198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36199   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36200   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36201
36202   arg1 = (Dali::PanGesture *)jarg1;
36203   arg2 = (Dali::Vector2 *)jarg2;
36204   if (arg1) (arg1)->screenDisplacement = *arg2;
36205 }
36206
36207
36208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36209   void * jresult ;
36210   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36211   Dali::Vector2 *result = 0 ;
36212
36213   arg1 = (Dali::PanGesture *)jarg1;
36214   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36215   jresult = (void *)result;
36216   return jresult;
36217 }
36218
36219
36220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36221   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36222   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36223
36224   arg1 = (Dali::PanGesture *)jarg1;
36225   arg2 = (Dali::Vector2 *)jarg2;
36226   if (arg1) (arg1)->screenPosition = *arg2;
36227 }
36228
36229
36230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36231   void * jresult ;
36232   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36233   Dali::Vector2 *result = 0 ;
36234
36235   arg1 = (Dali::PanGesture *)jarg1;
36236   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36237   jresult = (void *)result;
36238   return jresult;
36239 }
36240
36241
36242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36243   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36244   unsigned int arg2 ;
36245
36246   arg1 = (Dali::PanGesture *)jarg1;
36247   arg2 = (unsigned int)jarg2;
36248   if (arg1) (arg1)->numberOfTouches = arg2;
36249 }
36250
36251
36252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36253   unsigned int jresult ;
36254   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36255   unsigned int result;
36256
36257   arg1 = (Dali::PanGesture *)jarg1;
36258   result = (unsigned int) ((arg1)->numberOfTouches);
36259   jresult = result;
36260   return jresult;
36261 }
36262
36263
36264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36265   float jresult ;
36266   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36267   float result;
36268
36269   arg1 = (Dali::PanGesture *)jarg1;
36270   {
36271     try {
36272       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36273     } catch (std::out_of_range& e) {
36274       {
36275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36276       };
36277     } catch (std::exception& e) {
36278       {
36279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36280       };
36281     } catch (...) {
36282       {
36283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36284       };
36285     }
36286   }
36287   jresult = result;
36288   return jresult;
36289 }
36290
36291
36292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36293   float jresult ;
36294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36295   float result;
36296
36297   arg1 = (Dali::PanGesture *)jarg1;
36298   {
36299     try {
36300       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36301     } catch (std::out_of_range& e) {
36302       {
36303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36304       };
36305     } catch (std::exception& e) {
36306       {
36307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36308       };
36309     } catch (...) {
36310       {
36311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36312       };
36313     }
36314   }
36315   jresult = result;
36316   return jresult;
36317 }
36318
36319
36320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36321   float jresult ;
36322   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36323   float result;
36324
36325   arg1 = (Dali::PanGesture *)jarg1;
36326   {
36327     try {
36328       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36329     } catch (std::out_of_range& e) {
36330       {
36331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36332       };
36333     } catch (std::exception& e) {
36334       {
36335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36336       };
36337     } catch (...) {
36338       {
36339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36340       };
36341     }
36342   }
36343   jresult = result;
36344   return jresult;
36345 }
36346
36347
36348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36349   float jresult ;
36350   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36351   float result;
36352
36353   arg1 = (Dali::PanGesture *)jarg1;
36354   {
36355     try {
36356       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371   jresult = result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36377   void * jresult ;
36378   Dali::PinchGestureDetector *result = 0 ;
36379
36380   {
36381     try {
36382       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36383     } catch (std::out_of_range& e) {
36384       {
36385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36386       };
36387     } catch (std::exception& e) {
36388       {
36389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36390       };
36391     } catch (...) {
36392       {
36393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36394       };
36395     }
36396   }
36397   jresult = (void *)result;
36398   return jresult;
36399 }
36400
36401
36402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36403   void * jresult ;
36404   Dali::PinchGestureDetector result;
36405
36406   {
36407     try {
36408       result = Dali::PinchGestureDetector::New();
36409     } catch (std::out_of_range& e) {
36410       {
36411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36412       };
36413     } catch (std::exception& e) {
36414       {
36415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36416       };
36417     } catch (...) {
36418       {
36419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36420       };
36421     }
36422   }
36423   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36424   return jresult;
36425 }
36426
36427
36428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36429   void * jresult ;
36430   Dali::BaseHandle arg1 ;
36431   Dali::BaseHandle *argp1 ;
36432   Dali::PinchGestureDetector result;
36433
36434   argp1 = (Dali::BaseHandle *)jarg1;
36435   if (!argp1) {
36436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36437     return 0;
36438   }
36439   arg1 = *argp1;
36440   {
36441     try {
36442       result = Dali::PinchGestureDetector::DownCast(arg1);
36443     } catch (std::out_of_range& e) {
36444       {
36445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36446       };
36447     } catch (std::exception& e) {
36448       {
36449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36450       };
36451     } catch (...) {
36452       {
36453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36454       };
36455     }
36456   }
36457   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36458   return jresult;
36459 }
36460
36461
36462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36463   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36464
36465   arg1 = (Dali::PinchGestureDetector *)jarg1;
36466   {
36467     try {
36468       delete arg1;
36469     } catch (std::out_of_range& e) {
36470       {
36471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36472       };
36473     } catch (std::exception& e) {
36474       {
36475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36476       };
36477     } catch (...) {
36478       {
36479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36480       };
36481     }
36482   }
36483 }
36484
36485
36486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36487   void * jresult ;
36488   Dali::PinchGestureDetector *arg1 = 0 ;
36489   Dali::PinchGestureDetector *result = 0 ;
36490
36491   arg1 = (Dali::PinchGestureDetector *)jarg1;
36492   if (!arg1) {
36493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36494     return 0;
36495   }
36496   {
36497     try {
36498       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36499     } catch (std::out_of_range& e) {
36500       {
36501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36502       };
36503     } catch (std::exception& e) {
36504       {
36505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36506       };
36507     } catch (...) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36510       };
36511     }
36512   }
36513   jresult = (void *)result;
36514   return jresult;
36515 }
36516
36517
36518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36519   void * jresult ;
36520   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36521   Dali::PinchGestureDetector *arg2 = 0 ;
36522   Dali::PinchGestureDetector *result = 0 ;
36523
36524   arg1 = (Dali::PinchGestureDetector *)jarg1;
36525   arg2 = (Dali::PinchGestureDetector *)jarg2;
36526   if (!arg2) {
36527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36528     return 0;
36529   }
36530   {
36531     try {
36532       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36533     } catch (std::out_of_range& e) {
36534       {
36535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36536       };
36537     } catch (std::exception& e) {
36538       {
36539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36540       };
36541     } catch (...) {
36542       {
36543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36544       };
36545     }
36546   }
36547   jresult = (void *)result;
36548   return jresult;
36549 }
36550
36551
36552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36553   void * jresult ;
36554   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36555   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36556
36557   arg1 = (Dali::PinchGestureDetector *)jarg1;
36558   {
36559     try {
36560       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36561     } catch (std::out_of_range& e) {
36562       {
36563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36564       };
36565     } catch (std::exception& e) {
36566       {
36567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36568       };
36569     } catch (...) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36572       };
36573     }
36574   }
36575   jresult = (void *)result;
36576   return jresult;
36577 }
36578
36579
36580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36581   void * jresult ;
36582   Dali::Gesture::State arg1 ;
36583   Dali::PinchGesture *result = 0 ;
36584
36585   arg1 = (Dali::Gesture::State)jarg1;
36586   {
36587     try {
36588       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36589     } catch (std::out_of_range& e) {
36590       {
36591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36592       };
36593     } catch (std::exception& e) {
36594       {
36595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36596       };
36597     } catch (...) {
36598       {
36599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36600       };
36601     }
36602   }
36603   jresult = (void *)result;
36604   return jresult;
36605 }
36606
36607
36608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36609   void * jresult ;
36610   Dali::PinchGesture *arg1 = 0 ;
36611   Dali::PinchGesture *result = 0 ;
36612
36613   arg1 = (Dali::PinchGesture *)jarg1;
36614   if (!arg1) {
36615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36616     return 0;
36617   }
36618   {
36619     try {
36620       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36621     } catch (std::out_of_range& e) {
36622       {
36623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36624       };
36625     } catch (std::exception& e) {
36626       {
36627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36628       };
36629     } catch (...) {
36630       {
36631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36632       };
36633     }
36634   }
36635   jresult = (void *)result;
36636   return jresult;
36637 }
36638
36639
36640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36641   void * jresult ;
36642   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36643   Dali::PinchGesture *arg2 = 0 ;
36644   Dali::PinchGesture *result = 0 ;
36645
36646   arg1 = (Dali::PinchGesture *)jarg1;
36647   arg2 = (Dali::PinchGesture *)jarg2;
36648   if (!arg2) {
36649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36650     return 0;
36651   }
36652   {
36653     try {
36654       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36655     } catch (std::out_of_range& e) {
36656       {
36657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36658       };
36659     } catch (std::exception& e) {
36660       {
36661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36662       };
36663     } catch (...) {
36664       {
36665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36666       };
36667     }
36668   }
36669   jresult = (void *)result;
36670   return jresult;
36671 }
36672
36673
36674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36675   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36676
36677   arg1 = (Dali::PinchGesture *)jarg1;
36678   {
36679     try {
36680       delete arg1;
36681     } catch (std::out_of_range& e) {
36682       {
36683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36684       };
36685     } catch (std::exception& e) {
36686       {
36687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36688       };
36689     } catch (...) {
36690       {
36691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36692       };
36693     }
36694   }
36695 }
36696
36697
36698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36699   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36700   float arg2 ;
36701
36702   arg1 = (Dali::PinchGesture *)jarg1;
36703   arg2 = (float)jarg2;
36704   if (arg1) (arg1)->scale = arg2;
36705 }
36706
36707
36708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36709   float jresult ;
36710   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36711   float result;
36712
36713   arg1 = (Dali::PinchGesture *)jarg1;
36714   result = (float) ((arg1)->scale);
36715   jresult = result;
36716   return jresult;
36717 }
36718
36719
36720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36721   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36722   float arg2 ;
36723
36724   arg1 = (Dali::PinchGesture *)jarg1;
36725   arg2 = (float)jarg2;
36726   if (arg1) (arg1)->speed = arg2;
36727 }
36728
36729
36730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36731   float jresult ;
36732   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36733   float result;
36734
36735   arg1 = (Dali::PinchGesture *)jarg1;
36736   result = (float) ((arg1)->speed);
36737   jresult = result;
36738   return jresult;
36739 }
36740
36741
36742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36743   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36744   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36745
36746   arg1 = (Dali::PinchGesture *)jarg1;
36747   arg2 = (Dali::Vector2 *)jarg2;
36748   if (arg1) (arg1)->screenCenterPoint = *arg2;
36749 }
36750
36751
36752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36753   void * jresult ;
36754   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36755   Dali::Vector2 *result = 0 ;
36756
36757   arg1 = (Dali::PinchGesture *)jarg1;
36758   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36759   jresult = (void *)result;
36760   return jresult;
36761 }
36762
36763
36764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36765   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36766   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36767
36768   arg1 = (Dali::PinchGesture *)jarg1;
36769   arg2 = (Dali::Vector2 *)jarg2;
36770   if (arg1) (arg1)->localCenterPoint = *arg2;
36771 }
36772
36773
36774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36775   void * jresult ;
36776   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36777   Dali::Vector2 *result = 0 ;
36778
36779   arg1 = (Dali::PinchGesture *)jarg1;
36780   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36781   jresult = (void *)result;
36782   return jresult;
36783 }
36784
36785
36786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36787   void * jresult ;
36788   Dali::TapGestureDetector *result = 0 ;
36789
36790   {
36791     try {
36792       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36793     } catch (std::out_of_range& e) {
36794       {
36795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36796       };
36797     } catch (std::exception& e) {
36798       {
36799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36800       };
36801     } catch (...) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36804       };
36805     }
36806   }
36807   jresult = (void *)result;
36808   return jresult;
36809 }
36810
36811
36812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36813   void * jresult ;
36814   Dali::TapGestureDetector result;
36815
36816   {
36817     try {
36818       result = Dali::TapGestureDetector::New();
36819     } catch (std::out_of_range& e) {
36820       {
36821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36822       };
36823     } catch (std::exception& e) {
36824       {
36825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36826       };
36827     } catch (...) {
36828       {
36829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36830       };
36831     }
36832   }
36833   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36834   return jresult;
36835 }
36836
36837
36838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36839   void * jresult ;
36840   unsigned int arg1 ;
36841   Dali::TapGestureDetector result;
36842
36843   arg1 = (unsigned int)jarg1;
36844   {
36845     try {
36846       result = Dali::TapGestureDetector::New(arg1);
36847     } catch (std::out_of_range& e) {
36848       {
36849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36850       };
36851     } catch (std::exception& e) {
36852       {
36853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36854       };
36855     } catch (...) {
36856       {
36857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36858       };
36859     }
36860   }
36861   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36862   return jresult;
36863 }
36864
36865
36866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36867   void * jresult ;
36868   Dali::BaseHandle arg1 ;
36869   Dali::BaseHandle *argp1 ;
36870   Dali::TapGestureDetector result;
36871
36872   argp1 = (Dali::BaseHandle *)jarg1;
36873   if (!argp1) {
36874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36875     return 0;
36876   }
36877   arg1 = *argp1;
36878   {
36879     try {
36880       result = Dali::TapGestureDetector::DownCast(arg1);
36881     } catch (std::out_of_range& e) {
36882       {
36883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (std::exception& e) {
36886       {
36887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36892       };
36893     }
36894   }
36895   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36896   return jresult;
36897 }
36898
36899
36900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36901   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36902
36903   arg1 = (Dali::TapGestureDetector *)jarg1;
36904   {
36905     try {
36906       delete arg1;
36907     } catch (std::out_of_range& e) {
36908       {
36909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36910       };
36911     } catch (std::exception& e) {
36912       {
36913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36914       };
36915     } catch (...) {
36916       {
36917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36918       };
36919     }
36920   }
36921 }
36922
36923
36924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36925   void * jresult ;
36926   Dali::TapGestureDetector *arg1 = 0 ;
36927   Dali::TapGestureDetector *result = 0 ;
36928
36929   arg1 = (Dali::TapGestureDetector *)jarg1;
36930   if (!arg1) {
36931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36932     return 0;
36933   }
36934   {
36935     try {
36936       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36937     } catch (std::out_of_range& e) {
36938       {
36939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36940       };
36941     } catch (std::exception& e) {
36942       {
36943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36944       };
36945     } catch (...) {
36946       {
36947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36948       };
36949     }
36950   }
36951   jresult = (void *)result;
36952   return jresult;
36953 }
36954
36955
36956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36957   void * jresult ;
36958   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36959   Dali::TapGestureDetector *arg2 = 0 ;
36960   Dali::TapGestureDetector *result = 0 ;
36961
36962   arg1 = (Dali::TapGestureDetector *)jarg1;
36963   arg2 = (Dali::TapGestureDetector *)jarg2;
36964   if (!arg2) {
36965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36966     return 0;
36967   }
36968   {
36969     try {
36970       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36971     } catch (std::out_of_range& e) {
36972       {
36973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36974       };
36975     } catch (std::exception& e) {
36976       {
36977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36978       };
36979     } catch (...) {
36980       {
36981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36982       };
36983     }
36984   }
36985   jresult = (void *)result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36991   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36992   unsigned int arg2 ;
36993
36994   arg1 = (Dali::TapGestureDetector *)jarg1;
36995   arg2 = (unsigned int)jarg2;
36996   {
36997     try {
36998       (arg1)->SetMinimumTapsRequired(arg2);
36999     } catch (std::out_of_range& e) {
37000       {
37001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37002       };
37003     } catch (std::exception& e) {
37004       {
37005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37006       };
37007     } catch (...) {
37008       {
37009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37010       };
37011     }
37012   }
37013 }
37014
37015
37016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37017   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37018   unsigned int arg2 ;
37019
37020   arg1 = (Dali::TapGestureDetector *)jarg1;
37021   arg2 = (unsigned int)jarg2;
37022   {
37023     try {
37024       (arg1)->SetMaximumTapsRequired(arg2);
37025     } catch (std::out_of_range& e) {
37026       {
37027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37028       };
37029     } catch (std::exception& e) {
37030       {
37031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37032       };
37033     } catch (...) {
37034       {
37035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37036       };
37037     }
37038   }
37039 }
37040
37041
37042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37043   unsigned int jresult ;
37044   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37045   unsigned int result;
37046
37047   arg1 = (Dali::TapGestureDetector *)jarg1;
37048   {
37049     try {
37050       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37051     } catch (std::out_of_range& e) {
37052       {
37053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37054       };
37055     } catch (std::exception& e) {
37056       {
37057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (...) {
37060       {
37061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37062       };
37063     }
37064   }
37065   jresult = result;
37066   return jresult;
37067 }
37068
37069
37070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37071   unsigned int jresult ;
37072   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37073   unsigned int result;
37074
37075   arg1 = (Dali::TapGestureDetector *)jarg1;
37076   {
37077     try {
37078       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37079     } catch (std::out_of_range& e) {
37080       {
37081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37082       };
37083     } catch (std::exception& e) {
37084       {
37085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37086       };
37087     } catch (...) {
37088       {
37089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37090       };
37091     }
37092   }
37093   jresult = result;
37094   return jresult;
37095 }
37096
37097
37098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37099   void * jresult ;
37100   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37101   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37102
37103   arg1 = (Dali::TapGestureDetector *)jarg1;
37104   {
37105     try {
37106       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37107     } catch (std::out_of_range& e) {
37108       {
37109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37110       };
37111     } catch (std::exception& e) {
37112       {
37113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37114       };
37115     } catch (...) {
37116       {
37117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37118       };
37119     }
37120   }
37121   jresult = (void *)result;
37122   return jresult;
37123 }
37124
37125
37126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37127   void * jresult ;
37128   Dali::TapGesture *result = 0 ;
37129
37130   {
37131     try {
37132       result = (Dali::TapGesture *)new Dali::TapGesture();
37133     } catch (std::out_of_range& e) {
37134       {
37135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37136       };
37137     } catch (std::exception& e) {
37138       {
37139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37140       };
37141     } catch (...) {
37142       {
37143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37144       };
37145     }
37146   }
37147   jresult = (void *)result;
37148   return jresult;
37149 }
37150
37151
37152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37153   void * jresult ;
37154   Dali::TapGesture *arg1 = 0 ;
37155   Dali::TapGesture *result = 0 ;
37156
37157   arg1 = (Dali::TapGesture *)jarg1;
37158   if (!arg1) {
37159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37160     return 0;
37161   }
37162   {
37163     try {
37164       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37165     } catch (std::out_of_range& e) {
37166       {
37167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37168       };
37169     } catch (std::exception& e) {
37170       {
37171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37172       };
37173     } catch (...) {
37174       {
37175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37176       };
37177     }
37178   }
37179   jresult = (void *)result;
37180   return jresult;
37181 }
37182
37183
37184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37185   void * jresult ;
37186   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37187   Dali::TapGesture *arg2 = 0 ;
37188   Dali::TapGesture *result = 0 ;
37189
37190   arg1 = (Dali::TapGesture *)jarg1;
37191   arg2 = (Dali::TapGesture *)jarg2;
37192   if (!arg2) {
37193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37194     return 0;
37195   }
37196   {
37197     try {
37198       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37199     } catch (std::out_of_range& e) {
37200       {
37201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37202       };
37203     } catch (std::exception& e) {
37204       {
37205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37206       };
37207     } catch (...) {
37208       {
37209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37210       };
37211     }
37212   }
37213   jresult = (void *)result;
37214   return jresult;
37215 }
37216
37217
37218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37219   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37220
37221   arg1 = (Dali::TapGesture *)jarg1;
37222   {
37223     try {
37224       delete arg1;
37225     } catch (std::out_of_range& e) {
37226       {
37227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37228       };
37229     } catch (std::exception& e) {
37230       {
37231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37232       };
37233     } catch (...) {
37234       {
37235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37236       };
37237     }
37238   }
37239 }
37240
37241
37242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37243   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37244   unsigned int arg2 ;
37245
37246   arg1 = (Dali::TapGesture *)jarg1;
37247   arg2 = (unsigned int)jarg2;
37248   if (arg1) (arg1)->numberOfTaps = arg2;
37249 }
37250
37251
37252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37253   unsigned int jresult ;
37254   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37255   unsigned int result;
37256
37257   arg1 = (Dali::TapGesture *)jarg1;
37258   result = (unsigned int) ((arg1)->numberOfTaps);
37259   jresult = result;
37260   return jresult;
37261 }
37262
37263
37264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37265   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37266   unsigned int arg2 ;
37267
37268   arg1 = (Dali::TapGesture *)jarg1;
37269   arg2 = (unsigned int)jarg2;
37270   if (arg1) (arg1)->numberOfTouches = arg2;
37271 }
37272
37273
37274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37275   unsigned int jresult ;
37276   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37277   unsigned int result;
37278
37279   arg1 = (Dali::TapGesture *)jarg1;
37280   result = (unsigned int) ((arg1)->numberOfTouches);
37281   jresult = result;
37282   return jresult;
37283 }
37284
37285
37286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37287   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37288   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37289
37290   arg1 = (Dali::TapGesture *)jarg1;
37291   arg2 = (Dali::Vector2 *)jarg2;
37292   if (arg1) (arg1)->screenPoint = *arg2;
37293 }
37294
37295
37296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37297   void * jresult ;
37298   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37299   Dali::Vector2 *result = 0 ;
37300
37301   arg1 = (Dali::TapGesture *)jarg1;
37302   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37303   jresult = (void *)result;
37304   return jresult;
37305 }
37306
37307
37308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37309   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37310   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37311
37312   arg1 = (Dali::TapGesture *)jarg1;
37313   arg2 = (Dali::Vector2 *)jarg2;
37314   if (arg1) (arg1)->localPoint = *arg2;
37315 }
37316
37317
37318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37319   void * jresult ;
37320   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37321   Dali::Vector2 *result = 0 ;
37322
37323   arg1 = (Dali::TapGesture *)jarg1;
37324   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37325   jresult = (void *)result;
37326   return jresult;
37327 }
37328
37329
37330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37331   void * jresult ;
37332   Dali::AlphaFunction *result = 0 ;
37333
37334   {
37335     try {
37336       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37337     } catch (std::out_of_range& e) {
37338       {
37339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37340       };
37341     } catch (std::exception& e) {
37342       {
37343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37344       };
37345     } catch (...) {
37346       {
37347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37348       };
37349     }
37350   }
37351   jresult = (void *)result;
37352   return jresult;
37353 }
37354
37355
37356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37357   void * jresult ;
37358   Dali::AlphaFunction::BuiltinFunction arg1 ;
37359   Dali::AlphaFunction *result = 0 ;
37360
37361   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37362   {
37363     try {
37364       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37365     } catch (std::out_of_range& e) {
37366       {
37367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37368       };
37369     } catch (std::exception& e) {
37370       {
37371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37372       };
37373     } catch (...) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37376       };
37377     }
37378   }
37379   jresult = (void *)result;
37380   return jresult;
37381 }
37382
37383
37384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37385   void * jresult ;
37386   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37387   Dali::AlphaFunction *result = 0 ;
37388
37389   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37390   {
37391     try {
37392       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37393     } catch (std::out_of_range& e) {
37394       {
37395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37396       };
37397     } catch (std::exception& e) {
37398       {
37399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37400       };
37401     } catch (...) {
37402       {
37403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37404       };
37405     }
37406   }
37407   jresult = (void *)result;
37408   return jresult;
37409 }
37410
37411
37412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37413   void * jresult ;
37414   Dali::Vector2 *arg1 = 0 ;
37415   Dali::Vector2 *arg2 = 0 ;
37416   Dali::AlphaFunction *result = 0 ;
37417
37418   arg1 = (Dali::Vector2 *)jarg1;
37419   if (!arg1) {
37420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37421     return 0;
37422   }
37423   arg2 = (Dali::Vector2 *)jarg2;
37424   if (!arg2) {
37425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37426     return 0;
37427   }
37428   {
37429     try {
37430       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37431     } catch (std::out_of_range& e) {
37432       {
37433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37434       };
37435     } catch (std::exception& e) {
37436       {
37437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37438       };
37439     } catch (...) {
37440       {
37441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37442       };
37443     }
37444   }
37445   jresult = (void *)result;
37446   return jresult;
37447 }
37448
37449
37450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37451   void * jresult ;
37452   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37453   Dali::Vector4 result;
37454
37455   arg1 = (Dali::AlphaFunction *)jarg1;
37456   {
37457     try {
37458       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37459     } catch (std::out_of_range& e) {
37460       {
37461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37462       };
37463     } catch (std::exception& e) {
37464       {
37465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37466       };
37467     } catch (...) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37470       };
37471     }
37472   }
37473   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37474   return jresult;
37475 }
37476
37477
37478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37479   void * jresult ;
37480   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37481   Dali::AlphaFunctionPrototype result;
37482
37483   arg1 = (Dali::AlphaFunction *)jarg1;
37484   {
37485     try {
37486       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37487     } catch (std::out_of_range& e) {
37488       {
37489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37490       };
37491     } catch (std::exception& e) {
37492       {
37493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37494       };
37495     } catch (...) {
37496       {
37497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37498       };
37499     }
37500   }
37501   jresult = (void *)result;
37502   return jresult;
37503 }
37504
37505
37506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37507   int jresult ;
37508   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37509   Dali::AlphaFunction::BuiltinFunction result;
37510
37511   arg1 = (Dali::AlphaFunction *)jarg1;
37512   {
37513     try {
37514       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37515     } catch (std::out_of_range& e) {
37516       {
37517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37518       };
37519     } catch (std::exception& e) {
37520       {
37521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37522       };
37523     } catch (...) {
37524       {
37525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37526       };
37527     }
37528   }
37529   jresult = (int)result;
37530   return jresult;
37531 }
37532
37533
37534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37535   int jresult ;
37536   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37537   Dali::AlphaFunction::Mode result;
37538
37539   arg1 = (Dali::AlphaFunction *)jarg1;
37540   {
37541     try {
37542       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37543     } catch (std::out_of_range& e) {
37544       {
37545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37546       };
37547     } catch (std::exception& e) {
37548       {
37549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37550       };
37551     } catch (...) {
37552       {
37553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37554       };
37555     }
37556   }
37557   jresult = (int)result;
37558   return jresult;
37559 }
37560
37561
37562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37563   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37564
37565   arg1 = (Dali::AlphaFunction *)jarg1;
37566   {
37567     try {
37568       delete arg1;
37569     } catch (std::out_of_range& e) {
37570       {
37571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37572       };
37573     } catch (std::exception& e) {
37574       {
37575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37576       };
37577     } catch (...) {
37578       {
37579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37580       };
37581     }
37582   }
37583 }
37584
37585
37586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37587   void * jresult ;
37588   Dali::KeyFrames result;
37589
37590   {
37591     try {
37592       result = Dali::KeyFrames::New();
37593     } catch (std::out_of_range& e) {
37594       {
37595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37596       };
37597     } catch (std::exception& e) {
37598       {
37599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37600       };
37601     } catch (...) {
37602       {
37603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37604       };
37605     }
37606   }
37607   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37608   return jresult;
37609 }
37610
37611
37612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37613   void * jresult ;
37614   Dali::BaseHandle arg1 ;
37615   Dali::BaseHandle *argp1 ;
37616   Dali::KeyFrames result;
37617
37618   argp1 = (Dali::BaseHandle *)jarg1;
37619   if (!argp1) {
37620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37621     return 0;
37622   }
37623   arg1 = *argp1;
37624   {
37625     try {
37626       result = Dali::KeyFrames::DownCast(arg1);
37627     } catch (std::out_of_range& e) {
37628       {
37629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37630       };
37631     } catch (std::exception& e) {
37632       {
37633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37638       };
37639     }
37640   }
37641   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37642   return jresult;
37643 }
37644
37645
37646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37647   void * jresult ;
37648   Dali::KeyFrames *result = 0 ;
37649
37650   {
37651     try {
37652       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37653     } catch (std::out_of_range& e) {
37654       {
37655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37656       };
37657     } catch (std::exception& e) {
37658       {
37659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37660       };
37661     } catch (...) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37664       };
37665     }
37666   }
37667   jresult = (void *)result;
37668   return jresult;
37669 }
37670
37671
37672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37673   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37674
37675   arg1 = (Dali::KeyFrames *)jarg1;
37676   {
37677     try {
37678       delete arg1;
37679     } catch (std::out_of_range& e) {
37680       {
37681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37682       };
37683     } catch (std::exception& e) {
37684       {
37685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37686       };
37687     } catch (...) {
37688       {
37689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37690       };
37691     }
37692   }
37693 }
37694
37695
37696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37697   void * jresult ;
37698   Dali::KeyFrames *arg1 = 0 ;
37699   Dali::KeyFrames *result = 0 ;
37700
37701   arg1 = (Dali::KeyFrames *)jarg1;
37702   if (!arg1) {
37703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37704     return 0;
37705   }
37706   {
37707     try {
37708       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37709     } catch (std::out_of_range& e) {
37710       {
37711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37712       };
37713     } catch (std::exception& e) {
37714       {
37715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37716       };
37717     } catch (...) {
37718       {
37719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37720       };
37721     }
37722   }
37723   jresult = (void *)result;
37724   return jresult;
37725 }
37726
37727
37728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37729   void * jresult ;
37730   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37731   Dali::KeyFrames *arg2 = 0 ;
37732   Dali::KeyFrames *result = 0 ;
37733
37734   arg1 = (Dali::KeyFrames *)jarg1;
37735   arg2 = (Dali::KeyFrames *)jarg2;
37736   if (!arg2) {
37737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37738     return 0;
37739   }
37740   {
37741     try {
37742       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37743     } catch (std::out_of_range& e) {
37744       {
37745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37746       };
37747     } catch (std::exception& e) {
37748       {
37749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37750       };
37751     } catch (...) {
37752       {
37753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37754       };
37755     }
37756   }
37757   jresult = (void *)result;
37758   return jresult;
37759 }
37760
37761
37762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37763   int jresult ;
37764   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37765   Dali::Property::Type result;
37766
37767   arg1 = (Dali::KeyFrames *)jarg1;
37768   {
37769     try {
37770       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37771     } catch (std::out_of_range& e) {
37772       {
37773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37774       };
37775     } catch (std::exception& e) {
37776       {
37777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37778       };
37779     } catch (...) {
37780       {
37781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37782       };
37783     }
37784   }
37785   jresult = (int)result;
37786   return jresult;
37787 }
37788
37789
37790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37791   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37792   float arg2 ;
37793   Dali::Property::Value arg3 ;
37794   Dali::Property::Value *argp3 ;
37795
37796   arg1 = (Dali::KeyFrames *)jarg1;
37797   arg2 = (float)jarg2;
37798   argp3 = (Dali::Property::Value *)jarg3;
37799   if (!argp3) {
37800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37801     return ;
37802   }
37803   arg3 = *argp3;
37804   {
37805     try {
37806       (arg1)->Add(arg2,arg3);
37807     } catch (std::out_of_range& e) {
37808       {
37809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37810       };
37811     } catch (std::exception& e) {
37812       {
37813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37814       };
37815     } catch (...) {
37816       {
37817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37818       };
37819     }
37820   }
37821 }
37822
37823
37824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37825   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37826   float arg2 ;
37827   Dali::Property::Value arg3 ;
37828   Dali::AlphaFunction arg4 ;
37829   Dali::Property::Value *argp3 ;
37830   Dali::AlphaFunction *argp4 ;
37831
37832   arg1 = (Dali::KeyFrames *)jarg1;
37833   arg2 = (float)jarg2;
37834   argp3 = (Dali::Property::Value *)jarg3;
37835   if (!argp3) {
37836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37837     return ;
37838   }
37839   arg3 = *argp3;
37840   argp4 = (Dali::AlphaFunction *)jarg4;
37841   if (!argp4) {
37842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37843     return ;
37844   }
37845   arg4 = *argp4;
37846   {
37847     try {
37848       (arg1)->Add(arg2,arg3,arg4);
37849     } catch (std::out_of_range& e) {
37850       {
37851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37852       };
37853     } catch (std::exception& e) {
37854       {
37855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37856       };
37857     } catch (...) {
37858       {
37859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37860       };
37861     }
37862   }
37863 }
37864
37865
37866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37867   int jresult ;
37868   int result;
37869
37870   result = (int)Dali::Path::Property::POINTS;
37871   jresult = (int)result;
37872   return jresult;
37873 }
37874
37875
37876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37877   int jresult ;
37878   int result;
37879
37880   result = (int)Dali::Path::Property::CONTROL_POINTS;
37881   jresult = (int)result;
37882   return jresult;
37883 }
37884
37885
37886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37887   void * jresult ;
37888   Dali::Path::Property *result = 0 ;
37889
37890   {
37891     try {
37892       result = (Dali::Path::Property *)new Dali::Path::Property();
37893     } catch (std::out_of_range& e) {
37894       {
37895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37896       };
37897     } catch (std::exception& e) {
37898       {
37899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37900       };
37901     } catch (...) {
37902       {
37903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37904       };
37905     }
37906   }
37907   jresult = (void *)result;
37908   return jresult;
37909 }
37910
37911
37912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37913   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37914
37915   arg1 = (Dali::Path::Property *)jarg1;
37916   {
37917     try {
37918       delete arg1;
37919     } catch (std::out_of_range& e) {
37920       {
37921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37922       };
37923     } catch (std::exception& e) {
37924       {
37925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37926       };
37927     } catch (...) {
37928       {
37929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37930       };
37931     }
37932   }
37933 }
37934
37935
37936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37937   void * jresult ;
37938   Dali::Path result;
37939
37940   {
37941     try {
37942       result = Dali::Path::New();
37943     } catch (std::out_of_range& e) {
37944       {
37945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37946       };
37947     } catch (std::exception& e) {
37948       {
37949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37950       };
37951     } catch (...) {
37952       {
37953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37954       };
37955     }
37956   }
37957   jresult = new Dali::Path((const Dali::Path &)result);
37958   return jresult;
37959 }
37960
37961
37962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37963   void * jresult ;
37964   Dali::BaseHandle arg1 ;
37965   Dali::BaseHandle *argp1 ;
37966   Dali::Path result;
37967
37968   argp1 = (Dali::BaseHandle *)jarg1;
37969   if (!argp1) {
37970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37971     return 0;
37972   }
37973   arg1 = *argp1;
37974   {
37975     try {
37976       result = Dali::Path::DownCast(arg1);
37977     } catch (std::out_of_range& e) {
37978       {
37979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37980       };
37981     } catch (std::exception& e) {
37982       {
37983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37984       };
37985     } catch (...) {
37986       {
37987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37988       };
37989     }
37990   }
37991   jresult = new Dali::Path((const Dali::Path &)result);
37992   return jresult;
37993 }
37994
37995
37996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37997   void * jresult ;
37998   Dali::Path *result = 0 ;
37999
38000   {
38001     try {
38002       result = (Dali::Path *)new Dali::Path();
38003     } catch (std::out_of_range& e) {
38004       {
38005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38006       };
38007     } catch (std::exception& e) {
38008       {
38009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38010       };
38011     } catch (...) {
38012       {
38013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38014       };
38015     }
38016   }
38017   jresult = (void *)result;
38018   return jresult;
38019 }
38020
38021
38022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38023   Dali::Path *arg1 = (Dali::Path *) 0 ;
38024
38025   arg1 = (Dali::Path *)jarg1;
38026   {
38027     try {
38028       delete arg1;
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_new_Path__SWIG_1(void * jarg1) {
38047   void * jresult ;
38048   Dali::Path *arg1 = 0 ;
38049   Dali::Path *result = 0 ;
38050
38051   arg1 = (Dali::Path *)jarg1;
38052   if (!arg1) {
38053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38054     return 0;
38055   }
38056   {
38057     try {
38058       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38059     } catch (std::out_of_range& e) {
38060       {
38061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38062       };
38063     } catch (std::exception& e) {
38064       {
38065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38066       };
38067     } catch (...) {
38068       {
38069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38070       };
38071     }
38072   }
38073   jresult = (void *)result;
38074   return jresult;
38075 }
38076
38077
38078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38079   void * jresult ;
38080   Dali::Path *arg1 = (Dali::Path *) 0 ;
38081   Dali::Path *arg2 = 0 ;
38082   Dali::Path *result = 0 ;
38083
38084   arg1 = (Dali::Path *)jarg1;
38085   arg2 = (Dali::Path *)jarg2;
38086   if (!arg2) {
38087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38088     return 0;
38089   }
38090   {
38091     try {
38092       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38093     } catch (std::out_of_range& e) {
38094       {
38095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38096       };
38097     } catch (std::exception& e) {
38098       {
38099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38100       };
38101     } catch (...) {
38102       {
38103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38104       };
38105     }
38106   }
38107   jresult = (void *)result;
38108   return jresult;
38109 }
38110
38111
38112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38113   Dali::Path *arg1 = (Dali::Path *) 0 ;
38114   Dali::Vector3 *arg2 = 0 ;
38115
38116   arg1 = (Dali::Path *)jarg1;
38117   arg2 = (Dali::Vector3 *)jarg2;
38118   if (!arg2) {
38119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38120     return ;
38121   }
38122   {
38123     try {
38124       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38125     } catch (std::out_of_range& e) {
38126       {
38127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38128       };
38129     } catch (std::exception& e) {
38130       {
38131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38132       };
38133     } catch (...) {
38134       {
38135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38136       };
38137     }
38138   }
38139 }
38140
38141
38142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38143   Dali::Path *arg1 = (Dali::Path *) 0 ;
38144   Dali::Vector3 *arg2 = 0 ;
38145
38146   arg1 = (Dali::Path *)jarg1;
38147   arg2 = (Dali::Vector3 *)jarg2;
38148   if (!arg2) {
38149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38150     return ;
38151   }
38152   {
38153     try {
38154       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38155     } catch (std::out_of_range& e) {
38156       {
38157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38158       };
38159     } catch (std::exception& e) {
38160       {
38161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38162       };
38163     } catch (...) {
38164       {
38165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38166       };
38167     }
38168   }
38169 }
38170
38171
38172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38173   Dali::Path *arg1 = (Dali::Path *) 0 ;
38174   float arg2 ;
38175
38176   arg1 = (Dali::Path *)jarg1;
38177   arg2 = (float)jarg2;
38178   {
38179     try {
38180       (arg1)->GenerateControlPoints(arg2);
38181     } catch (std::out_of_range& e) {
38182       {
38183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38184       };
38185     } catch (std::exception& e) {
38186       {
38187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38188       };
38189     } catch (...) {
38190       {
38191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38192       };
38193     }
38194   }
38195 }
38196
38197
38198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38199   Dali::Path *arg1 = (Dali::Path *) 0 ;
38200   float arg2 ;
38201   Dali::Vector3 *arg3 = 0 ;
38202   Dali::Vector3 *arg4 = 0 ;
38203
38204   arg1 = (Dali::Path *)jarg1;
38205   arg2 = (float)jarg2;
38206   arg3 = (Dali::Vector3 *)jarg3;
38207   if (!arg3) {
38208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38209     return ;
38210   }
38211   arg4 = (Dali::Vector3 *)jarg4;
38212   if (!arg4) {
38213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38214     return ;
38215   }
38216   {
38217     try {
38218       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38219     } catch (std::out_of_range& e) {
38220       {
38221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38222       };
38223     } catch (std::exception& e) {
38224       {
38225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38226       };
38227     } catch (...) {
38228       {
38229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38230       };
38231     }
38232   }
38233 }
38234
38235
38236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38237   void * jresult ;
38238   Dali::Path *arg1 = (Dali::Path *) 0 ;
38239   size_t arg2 ;
38240   Dali::Vector3 *result = 0 ;
38241
38242   arg1 = (Dali::Path *)jarg1;
38243   arg2 = (size_t)jarg2;
38244   {
38245     try {
38246       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38247     } catch (std::out_of_range& e) {
38248       {
38249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38250       };
38251     } catch (std::exception& e) {
38252       {
38253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38254       };
38255     } catch (...) {
38256       {
38257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38258       };
38259     }
38260   }
38261   jresult = (void *)result;
38262   return jresult;
38263 }
38264
38265
38266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38267   void * jresult ;
38268   Dali::Path *arg1 = (Dali::Path *) 0 ;
38269   size_t arg2 ;
38270   Dali::Vector3 *result = 0 ;
38271
38272   arg1 = (Dali::Path *)jarg1;
38273   arg2 = (size_t)jarg2;
38274   {
38275     try {
38276       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38277     } catch (std::out_of_range& e) {
38278       {
38279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38280       };
38281     } catch (std::exception& e) {
38282       {
38283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38284       };
38285     } catch (...) {
38286       {
38287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38288       };
38289     }
38290   }
38291   jresult = (void *)result;
38292   return jresult;
38293 }
38294
38295
38296 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38297   unsigned long jresult ;
38298   Dali::Path *arg1 = (Dali::Path *) 0 ;
38299   size_t result;
38300
38301   arg1 = (Dali::Path *)jarg1;
38302   {
38303     try {
38304       result = ((Dali::Path const *)arg1)->GetPointCount();
38305     } catch (std::out_of_range& e) {
38306       {
38307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38308       };
38309     } catch (std::exception& e) {
38310       {
38311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38312       };
38313     } catch (...) {
38314       {
38315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38316       };
38317     }
38318   }
38319   jresult = (unsigned long)result;
38320   return jresult;
38321 }
38322
38323
38324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38325   void * jresult ;
38326   float arg1 ;
38327   Dali::TimePeriod *result = 0 ;
38328
38329   arg1 = (float)jarg1;
38330   {
38331     try {
38332       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38333     } catch (std::out_of_range& e) {
38334       {
38335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38336       };
38337     } catch (std::exception& e) {
38338       {
38339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38340       };
38341     } catch (...) {
38342       {
38343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38344       };
38345     }
38346   }
38347   jresult = (void *)result;
38348   return jresult;
38349 }
38350
38351
38352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38353   void * jresult ;
38354   float arg1 ;
38355   float arg2 ;
38356   Dali::TimePeriod *result = 0 ;
38357
38358   arg1 = (float)jarg1;
38359   arg2 = (float)jarg2;
38360   {
38361     try {
38362       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38363     } catch (std::out_of_range& e) {
38364       {
38365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38366       };
38367     } catch (std::exception& e) {
38368       {
38369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38370       };
38371     } catch (...) {
38372       {
38373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38374       };
38375     }
38376   }
38377   jresult = (void *)result;
38378   return jresult;
38379 }
38380
38381
38382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38383   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38384
38385   arg1 = (Dali::TimePeriod *)jarg1;
38386   {
38387     try {
38388       delete arg1;
38389     } catch (std::out_of_range& e) {
38390       {
38391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38392       };
38393     } catch (std::exception& e) {
38394       {
38395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38396       };
38397     } catch (...) {
38398       {
38399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38400       };
38401     }
38402   }
38403 }
38404
38405
38406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38407   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38408   float arg2 ;
38409
38410   arg1 = (Dali::TimePeriod *)jarg1;
38411   arg2 = (float)jarg2;
38412   if (arg1) (arg1)->delaySeconds = arg2;
38413 }
38414
38415
38416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38417   float jresult ;
38418   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38419   float result;
38420
38421   arg1 = (Dali::TimePeriod *)jarg1;
38422   result = (float) ((arg1)->delaySeconds);
38423   jresult = result;
38424   return jresult;
38425 }
38426
38427
38428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38429   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38430   float arg2 ;
38431
38432   arg1 = (Dali::TimePeriod *)jarg1;
38433   arg2 = (float)jarg2;
38434   if (arg1) (arg1)->durationSeconds = arg2;
38435 }
38436
38437
38438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38439   float jresult ;
38440   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38441   float result;
38442
38443   arg1 = (Dali::TimePeriod *)jarg1;
38444   result = (float) ((arg1)->durationSeconds);
38445   jresult = result;
38446   return jresult;
38447 }
38448
38449
38450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38451   void * jresult ;
38452   Dali::Animation *result = 0 ;
38453
38454   {
38455     try {
38456       result = (Dali::Animation *)new Dali::Animation();
38457     } catch (std::out_of_range& e) {
38458       {
38459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38460       };
38461     } catch (std::exception& e) {
38462       {
38463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38464       };
38465     } catch (...) {
38466       {
38467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38468       };
38469     }
38470   }
38471   jresult = (void *)result;
38472   return jresult;
38473 }
38474
38475
38476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38477   void * jresult ;
38478   float arg1 ;
38479   Dali::Animation result;
38480
38481   arg1 = (float)jarg1;
38482   {
38483     try {
38484       result = Dali::Animation::New(arg1);
38485     } catch (std::out_of_range& e) {
38486       {
38487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38488       };
38489     } catch (std::exception& e) {
38490       {
38491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38492       };
38493     } catch (...) {
38494       {
38495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38496       };
38497     }
38498   }
38499   jresult = new Dali::Animation((const Dali::Animation &)result);
38500   return jresult;
38501 }
38502
38503
38504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38505   void * jresult ;
38506   Dali::BaseHandle arg1 ;
38507   Dali::BaseHandle *argp1 ;
38508   Dali::Animation result;
38509
38510   argp1 = (Dali::BaseHandle *)jarg1;
38511   if (!argp1) {
38512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38513     return 0;
38514   }
38515   arg1 = *argp1;
38516   {
38517     try {
38518       result = Dali::Animation::DownCast(arg1);
38519     } catch (std::out_of_range& e) {
38520       {
38521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38522       };
38523     } catch (std::exception& e) {
38524       {
38525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38526       };
38527     } catch (...) {
38528       {
38529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38530       };
38531     }
38532   }
38533   jresult = new Dali::Animation((const Dali::Animation &)result);
38534   return jresult;
38535 }
38536
38537
38538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38539   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38540
38541   arg1 = (Dali::Animation *)jarg1;
38542   {
38543     try {
38544       delete arg1;
38545     } catch (std::out_of_range& e) {
38546       {
38547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38548       };
38549     } catch (std::exception& e) {
38550       {
38551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38552       };
38553     } catch (...) {
38554       {
38555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38556       };
38557     }
38558   }
38559 }
38560
38561
38562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38563   void * jresult ;
38564   Dali::Animation *arg1 = 0 ;
38565   Dali::Animation *result = 0 ;
38566
38567   arg1 = (Dali::Animation *)jarg1;
38568   if (!arg1) {
38569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38570     return 0;
38571   }
38572   {
38573     try {
38574       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38575     } catch (std::out_of_range& e) {
38576       {
38577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38578       };
38579     } catch (std::exception& e) {
38580       {
38581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38582       };
38583     } catch (...) {
38584       {
38585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38586       };
38587     }
38588   }
38589   jresult = (void *)result;
38590   return jresult;
38591 }
38592
38593
38594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38595   void * jresult ;
38596   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38597   Dali::Animation *arg2 = 0 ;
38598   Dali::Animation *result = 0 ;
38599
38600   arg1 = (Dali::Animation *)jarg1;
38601   arg2 = (Dali::Animation *)jarg2;
38602   if (!arg2) {
38603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38604     return 0;
38605   }
38606   {
38607     try {
38608       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38609     } catch (std::out_of_range& e) {
38610       {
38611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38612       };
38613     } catch (std::exception& e) {
38614       {
38615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38620       };
38621     }
38622   }
38623   jresult = (void *)result;
38624   return jresult;
38625 }
38626
38627
38628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38629   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38630   float arg2 ;
38631
38632   arg1 = (Dali::Animation *)jarg1;
38633   arg2 = (float)jarg2;
38634   {
38635     try {
38636       (arg1)->SetDuration(arg2);
38637     } catch (std::out_of_range& e) {
38638       {
38639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38640       };
38641     } catch (std::exception& e) {
38642       {
38643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38644       };
38645     } catch (...) {
38646       {
38647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38648       };
38649     }
38650   }
38651 }
38652
38653
38654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38655   float jresult ;
38656   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38657   float result;
38658
38659   arg1 = (Dali::Animation *)jarg1;
38660   {
38661     try {
38662       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38663     } catch (std::out_of_range& e) {
38664       {
38665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38666       };
38667     } catch (std::exception& e) {
38668       {
38669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38670       };
38671     } catch (...) {
38672       {
38673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38674       };
38675     }
38676   }
38677   jresult = result;
38678   return jresult;
38679 }
38680
38681
38682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38683   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38684   bool arg2 ;
38685
38686   arg1 = (Dali::Animation *)jarg1;
38687   arg2 = jarg2 ? true : false;
38688   {
38689     try {
38690       (arg1)->SetLooping(arg2);
38691     } catch (std::out_of_range& e) {
38692       {
38693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38694       };
38695     } catch (std::exception& e) {
38696       {
38697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38698       };
38699     } catch (...) {
38700       {
38701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38702       };
38703     }
38704   }
38705 }
38706
38707
38708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38709   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38710   int arg2 ;
38711
38712   arg1 = (Dali::Animation *)jarg1;
38713   arg2 = (int)jarg2;
38714   {
38715     try {
38716       (arg1)->SetLoopCount(arg2);
38717     } catch (std::out_of_range& e) {
38718       {
38719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38720       };
38721     } catch (std::exception& e) {
38722       {
38723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38724       };
38725     } catch (...) {
38726       {
38727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38728       };
38729     }
38730   }
38731 }
38732
38733
38734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38735   int jresult ;
38736   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38737   int result;
38738
38739   arg1 = (Dali::Animation *)jarg1;
38740   {
38741     try {
38742       result = (int)(arg1)->GetLoopCount();
38743     } catch (std::out_of_range& e) {
38744       {
38745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (std::exception& e) {
38748       {
38749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (...) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38754       };
38755     }
38756   }
38757   jresult = result;
38758   return jresult;
38759 }
38760
38761
38762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38763   int jresult ;
38764   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38765   int result;
38766
38767   arg1 = (Dali::Animation *)jarg1;
38768   {
38769     try {
38770       result = (int)(arg1)->GetCurrentLoop();
38771     } catch (std::out_of_range& e) {
38772       {
38773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38774       };
38775     } catch (std::exception& e) {
38776       {
38777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38778       };
38779     } catch (...) {
38780       {
38781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38782       };
38783     }
38784   }
38785   jresult = result;
38786   return jresult;
38787 }
38788
38789
38790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38791   unsigned int jresult ;
38792   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38793   bool result;
38794
38795   arg1 = (Dali::Animation *)jarg1;
38796   {
38797     try {
38798       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38799     } catch (std::out_of_range& e) {
38800       {
38801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38802       };
38803     } catch (std::exception& e) {
38804       {
38805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38806       };
38807     } catch (...) {
38808       {
38809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38810       };
38811     }
38812   }
38813   jresult = result;
38814   return jresult;
38815 }
38816
38817
38818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38819   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38820   Dali::Animation::EndAction arg2 ;
38821
38822   arg1 = (Dali::Animation *)jarg1;
38823   arg2 = (Dali::Animation::EndAction)jarg2;
38824   {
38825     try {
38826       (arg1)->SetEndAction(arg2);
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38838       };
38839     }
38840   }
38841 }
38842
38843
38844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38845   int jresult ;
38846   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38847   Dali::Animation::EndAction result;
38848
38849   arg1 = (Dali::Animation *)jarg1;
38850   {
38851     try {
38852       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38853     } catch (std::out_of_range& e) {
38854       {
38855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38856       };
38857     } catch (std::exception& e) {
38858       {
38859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38860       };
38861     } catch (...) {
38862       {
38863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38864       };
38865     }
38866   }
38867   jresult = (int)result;
38868   return jresult;
38869 }
38870
38871
38872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38873   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38874   Dali::Animation::EndAction arg2 ;
38875
38876   arg1 = (Dali::Animation *)jarg1;
38877   arg2 = (Dali::Animation::EndAction)jarg2;
38878   {
38879     try {
38880       (arg1)->SetDisconnectAction(arg2);
38881     } catch (std::out_of_range& e) {
38882       {
38883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38884       };
38885     } catch (std::exception& e) {
38886       {
38887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38888       };
38889     } catch (...) {
38890       {
38891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38892       };
38893     }
38894   }
38895 }
38896
38897
38898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38899   int jresult ;
38900   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38901   Dali::Animation::EndAction result;
38902
38903   arg1 = (Dali::Animation *)jarg1;
38904   {
38905     try {
38906       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38907     } catch (std::out_of_range& e) {
38908       {
38909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38910       };
38911     } catch (std::exception& e) {
38912       {
38913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38914       };
38915     } catch (...) {
38916       {
38917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38918       };
38919     }
38920   }
38921   jresult = (int)result;
38922   return jresult;
38923 }
38924
38925
38926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38927   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38928   Dali::AlphaFunction arg2 ;
38929   Dali::AlphaFunction *argp2 ;
38930
38931   arg1 = (Dali::Animation *)jarg1;
38932   argp2 = (Dali::AlphaFunction *)jarg2;
38933   if (!argp2) {
38934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38935     return ;
38936   }
38937   arg2 = *argp2;
38938   {
38939     try {
38940       (arg1)->SetDefaultAlphaFunction(arg2);
38941     } catch (std::out_of_range& e) {
38942       {
38943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38944       };
38945     } catch (std::exception& e) {
38946       {
38947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38948       };
38949     } catch (...) {
38950       {
38951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38952       };
38953     }
38954   }
38955 }
38956
38957
38958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38959   void * jresult ;
38960   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38961   Dali::AlphaFunction result;
38962
38963   arg1 = (Dali::Animation *)jarg1;
38964   {
38965     try {
38966       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38967     } catch (std::out_of_range& e) {
38968       {
38969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38970       };
38971     } catch (std::exception& e) {
38972       {
38973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38974       };
38975     } catch (...) {
38976       {
38977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38978       };
38979     }
38980   }
38981   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38982   return jresult;
38983 }
38984
38985
38986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38987   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38988   float arg2 ;
38989
38990   arg1 = (Dali::Animation *)jarg1;
38991   arg2 = (float)jarg2;
38992   {
38993     try {
38994       (arg1)->SetCurrentProgress(arg2);
38995     } catch (std::out_of_range& e) {
38996       {
38997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38998       };
38999     } catch (std::exception& e) {
39000       {
39001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39002       };
39003     } catch (...) {
39004       {
39005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39006       };
39007     }
39008   }
39009 }
39010
39011
39012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39013   float jresult ;
39014   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39015   float result;
39016
39017   arg1 = (Dali::Animation *)jarg1;
39018   {
39019     try {
39020       result = (float)(arg1)->GetCurrentProgress();
39021     } catch (std::out_of_range& e) {
39022       {
39023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39024       };
39025     } catch (std::exception& e) {
39026       {
39027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39028       };
39029     } catch (...) {
39030       {
39031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39032       };
39033     }
39034   }
39035   jresult = result;
39036   return jresult;
39037 }
39038
39039
39040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39041   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39042   float arg2 ;
39043
39044   arg1 = (Dali::Animation *)jarg1;
39045   arg2 = (float)jarg2;
39046   {
39047     try {
39048       (arg1)->SetSpeedFactor(arg2);
39049     } catch (std::out_of_range& e) {
39050       {
39051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39052       };
39053     } catch (std::exception& e) {
39054       {
39055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39056       };
39057     } catch (...) {
39058       {
39059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39060       };
39061     }
39062   }
39063 }
39064
39065
39066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39067   float jresult ;
39068   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39069   float result;
39070
39071   arg1 = (Dali::Animation *)jarg1;
39072   {
39073     try {
39074       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39075     } catch (std::out_of_range& e) {
39076       {
39077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (std::exception& e) {
39080       {
39081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39082       };
39083     } catch (...) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39086       };
39087     }
39088   }
39089   jresult = result;
39090   return jresult;
39091 }
39092
39093
39094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39096   Dali::Vector2 *arg2 = 0 ;
39097
39098   arg1 = (Dali::Animation *)jarg1;
39099   arg2 = (Dali::Vector2 *)jarg2;
39100   if (!arg2) {
39101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39102     return ;
39103   }
39104   {
39105     try {
39106       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39107     } catch (std::out_of_range& e) {
39108       {
39109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39110       };
39111     } catch (std::exception& e) {
39112       {
39113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39114       };
39115     } catch (...) {
39116       {
39117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39118       };
39119     }
39120   }
39121 }
39122
39123
39124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39125   void * jresult ;
39126   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39127   Dali::Vector2 result;
39128
39129   arg1 = (Dali::Animation *)jarg1;
39130   {
39131     try {
39132       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39144       };
39145     }
39146   }
39147   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39148   return jresult;
39149 }
39150
39151
39152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39153   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39154
39155   arg1 = (Dali::Animation *)jarg1;
39156   {
39157     try {
39158       (arg1)->Play();
39159     } catch (std::out_of_range& e) {
39160       {
39161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39162       };
39163     } catch (std::exception& e) {
39164       {
39165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39166       };
39167     } catch (...) {
39168       {
39169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39170       };
39171     }
39172   }
39173 }
39174
39175
39176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39177   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39178   float arg2 ;
39179
39180   arg1 = (Dali::Animation *)jarg1;
39181   arg2 = (float)jarg2;
39182   {
39183     try {
39184       (arg1)->PlayFrom(arg2);
39185     } catch (std::out_of_range& e) {
39186       {
39187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39188       };
39189     } catch (std::exception& e) {
39190       {
39191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39192       };
39193     } catch (...) {
39194       {
39195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39196       };
39197     }
39198   }
39199 }
39200
39201
39202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39203   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39204
39205   arg1 = (Dali::Animation *)jarg1;
39206   {
39207     try {
39208       (arg1)->Pause();
39209     } catch (std::out_of_range& e) {
39210       {
39211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39212       };
39213     } catch (std::exception& e) {
39214       {
39215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39216       };
39217     } catch (...) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39220       };
39221     }
39222   }
39223 }
39224
39225
39226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39227   int jresult ;
39228   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39229   Dali::Animation::State result;
39230
39231   arg1 = (Dali::Animation *)jarg1;
39232   {
39233     try {
39234       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39235     } catch (std::out_of_range& e) {
39236       {
39237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39238       };
39239     } catch (std::exception& e) {
39240       {
39241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39242       };
39243     } catch (...) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39246       };
39247     }
39248   }
39249   jresult = (int)result;
39250   return jresult;
39251 }
39252
39253
39254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39255   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39256
39257   arg1 = (Dali::Animation *)jarg1;
39258   {
39259     try {
39260       (arg1)->Stop();
39261     } catch (std::out_of_range& e) {
39262       {
39263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39264       };
39265     } catch (std::exception& e) {
39266       {
39267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39268       };
39269     } catch (...) {
39270       {
39271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39272       };
39273     }
39274   }
39275 }
39276
39277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
39278   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39279
39280   Dali::Animation arg1 = *argp1;
39281   float arg2 = (float)jarg2;
39282
39283   {
39284     try {
39285       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
39286     } catch (std::out_of_range& e) {
39287       {
39288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39289       };
39290     } catch (std::exception& e) {
39291       {
39292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39293       };
39294     } catch (...) {
39295       {
39296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39297       };
39298     }
39299   }
39300 }
39301
39302
39303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
39304   float jresult ;
39305   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39306   float result;
39307
39308   Dali::Animation arg1 = *argp1;
39309   {
39310     try {
39311       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
39312     } catch (std::out_of_range& e) {
39313       {
39314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39315       };
39316     } catch (std::exception& e) {
39317       {
39318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39319       };
39320     } catch (...) {
39321       {
39322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39323       };
39324     }
39325   }
39326   jresult = result;
39327   return jresult;
39328 }
39329
39330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39331   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39332
39333   arg1 = (Dali::Animation *)jarg1;
39334   {
39335     try {
39336       (arg1)->Clear();
39337     } catch (std::out_of_range& e) {
39338       {
39339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39340       };
39341     } catch (std::exception& e) {
39342       {
39343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39344       };
39345     } catch (...) {
39346       {
39347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39348       };
39349     }
39350   }
39351 }
39352
39353
39354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39355   void * jresult ;
39356   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39357   Dali::Animation::AnimationSignalType *result = 0 ;
39358
39359   arg1 = (Dali::Animation *)jarg1;
39360   {
39361     try {
39362       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39363     } catch (std::out_of_range& e) {
39364       {
39365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39366       };
39367     } catch (std::exception& e) {
39368       {
39369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39370       };
39371     } catch (...) {
39372       {
39373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39374       };
39375     }
39376   }
39377   jresult = (void *)result;
39378   return jresult;
39379 }
39380
39381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
39382   void * jresult ;
39383   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
39384   Dali::Animation::AnimationSignalType *result = 0 ;
39385
39386   Dali::Animation arg1 = *argp1;
39387   {
39388     try {
39389       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
39390     } catch (std::out_of_range& e) {
39391       {
39392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39393       };
39394     } catch (std::exception& e) {
39395       {
39396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39397       };
39398     } catch (...) {
39399       {
39400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39401       };
39402     }
39403   }
39404   jresult = (void *)result;
39405   return jresult;
39406 }
39407
39408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39409   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39410   SwigValueWrapper< Dali::Property > arg2 ;
39411   Dali::Property::Value arg3 ;
39412   Dali::Property *argp2 ;
39413   Dali::Property::Value *argp3 ;
39414
39415   arg1 = (Dali::Animation *)jarg1;
39416   argp2 = (Dali::Property *)jarg2;
39417   if (!argp2) {
39418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39419     return ;
39420   }
39421   arg2 = *argp2;
39422   argp3 = (Dali::Property::Value *)jarg3;
39423   if (!argp3) {
39424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39425     return ;
39426   }
39427   arg3 = *argp3;
39428   {
39429     try {
39430       (arg1)->AnimateBy(arg2,arg3);
39431     } catch (std::out_of_range& e) {
39432       {
39433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39434       };
39435     } catch (std::exception& e) {
39436       {
39437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (...) {
39440       {
39441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39442       };
39443     }
39444   }
39445 }
39446
39447
39448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39449   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39450   SwigValueWrapper< Dali::Property > arg2 ;
39451   Dali::Property::Value arg3 ;
39452   Dali::AlphaFunction arg4 ;
39453   Dali::Property *argp2 ;
39454   Dali::Property::Value *argp3 ;
39455   Dali::AlphaFunction *argp4 ;
39456
39457   arg1 = (Dali::Animation *)jarg1;
39458   argp2 = (Dali::Property *)jarg2;
39459   if (!argp2) {
39460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39461     return ;
39462   }
39463   arg2 = *argp2;
39464   argp3 = (Dali::Property::Value *)jarg3;
39465   if (!argp3) {
39466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39467     return ;
39468   }
39469   arg3 = *argp3;
39470   argp4 = (Dali::AlphaFunction *)jarg4;
39471   if (!argp4) {
39472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39473     return ;
39474   }
39475   arg4 = *argp4;
39476   {
39477     try {
39478       (arg1)->AnimateBy(arg2,arg3,arg4);
39479     } catch (std::out_of_range& e) {
39480       {
39481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39482       };
39483     } catch (std::exception& e) {
39484       {
39485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39486       };
39487     } catch (...) {
39488       {
39489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39490       };
39491     }
39492   }
39493 }
39494
39495
39496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39497   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39498   SwigValueWrapper< Dali::Property > arg2 ;
39499   Dali::Property::Value arg3 ;
39500   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39501   Dali::Property *argp2 ;
39502   Dali::Property::Value *argp3 ;
39503   Dali::TimePeriod *argp4 ;
39504
39505   arg1 = (Dali::Animation *)jarg1;
39506   argp2 = (Dali::Property *)jarg2;
39507   if (!argp2) {
39508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39509     return ;
39510   }
39511   arg2 = *argp2;
39512   argp3 = (Dali::Property::Value *)jarg3;
39513   if (!argp3) {
39514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39515     return ;
39516   }
39517   arg3 = *argp3;
39518   argp4 = (Dali::TimePeriod *)jarg4;
39519   if (!argp4) {
39520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39521     return ;
39522   }
39523   arg4 = *argp4;
39524   {
39525     try {
39526       (arg1)->AnimateBy(arg2,arg3,arg4);
39527     } catch (std::out_of_range& e) {
39528       {
39529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39530       };
39531     } catch (std::exception& e) {
39532       {
39533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39534       };
39535     } catch (...) {
39536       {
39537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39538       };
39539     }
39540   }
39541 }
39542
39543
39544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39545   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39546   SwigValueWrapper< Dali::Property > arg2 ;
39547   Dali::Property::Value arg3 ;
39548   Dali::AlphaFunction arg4 ;
39549   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39550   Dali::Property *argp2 ;
39551   Dali::Property::Value *argp3 ;
39552   Dali::AlphaFunction *argp4 ;
39553   Dali::TimePeriod *argp5 ;
39554
39555   arg1 = (Dali::Animation *)jarg1;
39556   argp2 = (Dali::Property *)jarg2;
39557   if (!argp2) {
39558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39559     return ;
39560   }
39561   arg2 = *argp2;
39562   argp3 = (Dali::Property::Value *)jarg3;
39563   if (!argp3) {
39564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39565     return ;
39566   }
39567   arg3 = *argp3;
39568   argp4 = (Dali::AlphaFunction *)jarg4;
39569   if (!argp4) {
39570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39571     return ;
39572   }
39573   arg4 = *argp4;
39574   argp5 = (Dali::TimePeriod *)jarg5;
39575   if (!argp5) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39577     return ;
39578   }
39579   arg5 = *argp5;
39580   {
39581     try {
39582       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39583     } catch (std::out_of_range& e) {
39584       {
39585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39586       };
39587     } catch (std::exception& e) {
39588       {
39589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39590       };
39591     } catch (...) {
39592       {
39593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39594       };
39595     }
39596   }
39597 }
39598
39599
39600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39601   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39602   SwigValueWrapper< Dali::Property > arg2 ;
39603   Dali::Property::Value arg3 ;
39604   Dali::Property *argp2 ;
39605   Dali::Property::Value *argp3 ;
39606
39607   arg1 = (Dali::Animation *)jarg1;
39608   argp2 = (Dali::Property *)jarg2;
39609   if (!argp2) {
39610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39611     return ;
39612   }
39613   arg2 = *argp2;
39614   argp3 = (Dali::Property::Value *)jarg3;
39615   if (!argp3) {
39616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39617     return ;
39618   }
39619   arg3 = *argp3;
39620   {
39621     try {
39622       (arg1)->AnimateTo(arg2,arg3);
39623     } catch (std::out_of_range& e) {
39624       {
39625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39626       };
39627     } catch (std::exception& e) {
39628       {
39629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39630       };
39631     } catch (...) {
39632       {
39633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39634       };
39635     }
39636   }
39637 }
39638
39639
39640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39641   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39642   SwigValueWrapper< Dali::Property > arg2 ;
39643   Dali::Property::Value arg3 ;
39644   Dali::AlphaFunction arg4 ;
39645   Dali::Property *argp2 ;
39646   Dali::Property::Value *argp3 ;
39647   Dali::AlphaFunction *argp4 ;
39648
39649   arg1 = (Dali::Animation *)jarg1;
39650   argp2 = (Dali::Property *)jarg2;
39651   if (!argp2) {
39652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39653     return ;
39654   }
39655   arg2 = *argp2;
39656   argp3 = (Dali::Property::Value *)jarg3;
39657   if (!argp3) {
39658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39659     return ;
39660   }
39661   arg3 = *argp3;
39662   argp4 = (Dali::AlphaFunction *)jarg4;
39663   if (!argp4) {
39664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39665     return ;
39666   }
39667   arg4 = *argp4;
39668   {
39669     try {
39670       (arg1)->AnimateTo(arg2,arg3,arg4);
39671     } catch (std::out_of_range& e) {
39672       {
39673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39674       };
39675     } catch (std::exception& e) {
39676       {
39677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39678       };
39679     } catch (...) {
39680       {
39681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39682       };
39683     }
39684   }
39685 }
39686
39687
39688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39689   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39690   SwigValueWrapper< Dali::Property > arg2 ;
39691   Dali::Property::Value arg3 ;
39692   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39693   Dali::Property *argp2 ;
39694   Dali::Property::Value *argp3 ;
39695   Dali::TimePeriod *argp4 ;
39696
39697   arg1 = (Dali::Animation *)jarg1;
39698   argp2 = (Dali::Property *)jarg2;
39699   if (!argp2) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39701     return ;
39702   }
39703   arg2 = *argp2;
39704   argp3 = (Dali::Property::Value *)jarg3;
39705   if (!argp3) {
39706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39707     return ;
39708   }
39709   arg3 = *argp3;
39710   argp4 = (Dali::TimePeriod *)jarg4;
39711   if (!argp4) {
39712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39713     return ;
39714   }
39715   arg4 = *argp4;
39716   {
39717     try {
39718       (arg1)->AnimateTo(arg2,arg3,arg4);
39719     } catch (std::out_of_range& e) {
39720       {
39721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39722       };
39723     } catch (std::exception& e) {
39724       {
39725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39726       };
39727     } catch (...) {
39728       {
39729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39730       };
39731     }
39732   }
39733 }
39734
39735
39736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39737   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39738   SwigValueWrapper< Dali::Property > arg2 ;
39739   Dali::Property::Value arg3 ;
39740   Dali::AlphaFunction arg4 ;
39741   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39742   Dali::Property *argp2 ;
39743   Dali::Property::Value *argp3 ;
39744   Dali::AlphaFunction *argp4 ;
39745   Dali::TimePeriod *argp5 ;
39746
39747   arg1 = (Dali::Animation *)jarg1;
39748   argp2 = (Dali::Property *)jarg2;
39749   if (!argp2) {
39750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39751     return ;
39752   }
39753   arg2 = *argp2;
39754   argp3 = (Dali::Property::Value *)jarg3;
39755   if (!argp3) {
39756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39757     return ;
39758   }
39759   arg3 = *argp3;
39760   argp4 = (Dali::AlphaFunction *)jarg4;
39761   if (!argp4) {
39762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39763     return ;
39764   }
39765   arg4 = *argp4;
39766   argp5 = (Dali::TimePeriod *)jarg5;
39767   if (!argp5) {
39768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39769     return ;
39770   }
39771   arg5 = *argp5;
39772   {
39773     try {
39774       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39775     } catch (std::out_of_range& e) {
39776       {
39777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39778       };
39779     } catch (std::exception& e) {
39780       {
39781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39782       };
39783     } catch (...) {
39784       {
39785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39786       };
39787     }
39788   }
39789 }
39790
39791
39792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39794   SwigValueWrapper< Dali::Property > arg2 ;
39795   Dali::KeyFrames *arg3 = 0 ;
39796   Dali::Property *argp2 ;
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   {
39811     try {
39812       (arg1)->AnimateBetween(arg2,*arg3);
39813     } catch (std::out_of_range& e) {
39814       {
39815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39816       };
39817     } catch (std::exception& e) {
39818       {
39819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39820       };
39821     } catch (...) {
39822       {
39823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39824       };
39825     }
39826   }
39827 }
39828
39829
39830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39831   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39832   SwigValueWrapper< Dali::Property > arg2 ;
39833   Dali::KeyFrames *arg3 = 0 ;
39834   Dali::Animation::Interpolation arg4 ;
39835   Dali::Property *argp2 ;
39836
39837   arg1 = (Dali::Animation *)jarg1;
39838   argp2 = (Dali::Property *)jarg2;
39839   if (!argp2) {
39840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39841     return ;
39842   }
39843   arg2 = *argp2;
39844   arg3 = (Dali::KeyFrames *)jarg3;
39845   if (!arg3) {
39846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39847     return ;
39848   }
39849   arg4 = (Dali::Animation::Interpolation)jarg4;
39850   {
39851     try {
39852       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39853     } catch (std::out_of_range& e) {
39854       {
39855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39856       };
39857     } catch (std::exception& e) {
39858       {
39859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39860       };
39861     } catch (...) {
39862       {
39863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39864       };
39865     }
39866   }
39867 }
39868
39869
39870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39871   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39872   SwigValueWrapper< Dali::Property > arg2 ;
39873   Dali::KeyFrames *arg3 = 0 ;
39874   Dali::AlphaFunction arg4 ;
39875   Dali::Property *argp2 ;
39876   Dali::AlphaFunction *argp4 ;
39877
39878   arg1 = (Dali::Animation *)jarg1;
39879   argp2 = (Dali::Property *)jarg2;
39880   if (!argp2) {
39881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39882     return ;
39883   }
39884   arg2 = *argp2;
39885   arg3 = (Dali::KeyFrames *)jarg3;
39886   if (!arg3) {
39887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39888     return ;
39889   }
39890   argp4 = (Dali::AlphaFunction *)jarg4;
39891   if (!argp4) {
39892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39893     return ;
39894   }
39895   arg4 = *argp4;
39896   {
39897     try {
39898       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39899     } catch (std::out_of_range& e) {
39900       {
39901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39902       };
39903     } catch (std::exception& e) {
39904       {
39905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39906       };
39907     } catch (...) {
39908       {
39909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39910       };
39911     }
39912   }
39913 }
39914
39915
39916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39917   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39918   SwigValueWrapper< Dali::Property > arg2 ;
39919   Dali::KeyFrames *arg3 = 0 ;
39920   Dali::AlphaFunction arg4 ;
39921   Dali::Animation::Interpolation arg5 ;
39922   Dali::Property *argp2 ;
39923   Dali::AlphaFunction *argp4 ;
39924
39925   arg1 = (Dali::Animation *)jarg1;
39926   argp2 = (Dali::Property *)jarg2;
39927   if (!argp2) {
39928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39929     return ;
39930   }
39931   arg2 = *argp2;
39932   arg3 = (Dali::KeyFrames *)jarg3;
39933   if (!arg3) {
39934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39935     return ;
39936   }
39937   argp4 = (Dali::AlphaFunction *)jarg4;
39938   if (!argp4) {
39939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39940     return ;
39941   }
39942   arg4 = *argp4;
39943   arg5 = (Dali::Animation::Interpolation)jarg5;
39944   {
39945     try {
39946       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39947     } catch (std::out_of_range& e) {
39948       {
39949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39950       };
39951     } catch (std::exception& e) {
39952       {
39953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39954       };
39955     } catch (...) {
39956       {
39957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39958       };
39959     }
39960   }
39961 }
39962
39963
39964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39965   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39966   SwigValueWrapper< Dali::Property > arg2 ;
39967   Dali::KeyFrames *arg3 = 0 ;
39968   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39969   Dali::Property *argp2 ;
39970   Dali::TimePeriod *argp4 ;
39971
39972   arg1 = (Dali::Animation *)jarg1;
39973   argp2 = (Dali::Property *)jarg2;
39974   if (!argp2) {
39975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39976     return ;
39977   }
39978   arg2 = *argp2;
39979   arg3 = (Dali::KeyFrames *)jarg3;
39980   if (!arg3) {
39981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39982     return ;
39983   }
39984   argp4 = (Dali::TimePeriod *)jarg4;
39985   if (!argp4) {
39986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39987     return ;
39988   }
39989   arg4 = *argp4;
39990   {
39991     try {
39992       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39993     } catch (std::out_of_range& e) {
39994       {
39995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39996       };
39997     } catch (std::exception& e) {
39998       {
39999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40000       };
40001     } catch (...) {
40002       {
40003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40004       };
40005     }
40006   }
40007 }
40008
40009
40010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40011   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40012   SwigValueWrapper< Dali::Property > arg2 ;
40013   Dali::KeyFrames *arg3 = 0 ;
40014   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40015   Dali::Animation::Interpolation arg5 ;
40016   Dali::Property *argp2 ;
40017   Dali::TimePeriod *argp4 ;
40018
40019   arg1 = (Dali::Animation *)jarg1;
40020   argp2 = (Dali::Property *)jarg2;
40021   if (!argp2) {
40022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40023     return ;
40024   }
40025   arg2 = *argp2;
40026   arg3 = (Dali::KeyFrames *)jarg3;
40027   if (!arg3) {
40028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40029     return ;
40030   }
40031   argp4 = (Dali::TimePeriod *)jarg4;
40032   if (!argp4) {
40033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40034     return ;
40035   }
40036   arg4 = *argp4;
40037   arg5 = (Dali::Animation::Interpolation)jarg5;
40038   {
40039     try {
40040       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40041     } catch (std::out_of_range& e) {
40042       {
40043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40044       };
40045     } catch (std::exception& e) {
40046       {
40047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40048       };
40049     } catch (...) {
40050       {
40051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40052       };
40053     }
40054   }
40055 }
40056
40057
40058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40059   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40060   SwigValueWrapper< Dali::Property > arg2 ;
40061   Dali::KeyFrames *arg3 = 0 ;
40062   Dali::AlphaFunction arg4 ;
40063   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40064   Dali::Property *argp2 ;
40065   Dali::AlphaFunction *argp4 ;
40066   Dali::TimePeriod *argp5 ;
40067
40068   arg1 = (Dali::Animation *)jarg1;
40069   argp2 = (Dali::Property *)jarg2;
40070   if (!argp2) {
40071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40072     return ;
40073   }
40074   arg2 = *argp2;
40075   arg3 = (Dali::KeyFrames *)jarg3;
40076   if (!arg3) {
40077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40078     return ;
40079   }
40080   argp4 = (Dali::AlphaFunction *)jarg4;
40081   if (!argp4) {
40082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40083     return ;
40084   }
40085   arg4 = *argp4;
40086   argp5 = (Dali::TimePeriod *)jarg5;
40087   if (!argp5) {
40088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40089     return ;
40090   }
40091   arg5 = *argp5;
40092   {
40093     try {
40094       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40095     } catch (std::out_of_range& e) {
40096       {
40097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40098       };
40099     } catch (std::exception& e) {
40100       {
40101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40102       };
40103     } catch (...) {
40104       {
40105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40106       };
40107     }
40108   }
40109 }
40110
40111
40112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40113   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40114   SwigValueWrapper< Dali::Property > arg2 ;
40115   Dali::KeyFrames *arg3 = 0 ;
40116   Dali::AlphaFunction arg4 ;
40117   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40118   Dali::Animation::Interpolation arg6 ;
40119   Dali::Property *argp2 ;
40120   Dali::AlphaFunction *argp4 ;
40121   Dali::TimePeriod *argp5 ;
40122
40123   arg1 = (Dali::Animation *)jarg1;
40124   argp2 = (Dali::Property *)jarg2;
40125   if (!argp2) {
40126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40127     return ;
40128   }
40129   arg2 = *argp2;
40130   arg3 = (Dali::KeyFrames *)jarg3;
40131   if (!arg3) {
40132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40133     return ;
40134   }
40135   argp4 = (Dali::AlphaFunction *)jarg4;
40136   if (!argp4) {
40137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40138     return ;
40139   }
40140   arg4 = *argp4;
40141   argp5 = (Dali::TimePeriod *)jarg5;
40142   if (!argp5) {
40143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40144     return ;
40145   }
40146   arg5 = *argp5;
40147   arg6 = (Dali::Animation::Interpolation)jarg6;
40148   {
40149     try {
40150       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40151     } catch (std::out_of_range& e) {
40152       {
40153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40154       };
40155     } catch (std::exception& e) {
40156       {
40157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40158       };
40159     } catch (...) {
40160       {
40161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40162       };
40163     }
40164   }
40165 }
40166
40167
40168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40169   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40170   Dali::Actor arg2 ;
40171   Dali::Path arg3 ;
40172   Dali::Vector3 *arg4 = 0 ;
40173   Dali::Actor *argp2 ;
40174   Dali::Path *argp3 ;
40175
40176   arg1 = (Dali::Animation *)jarg1;
40177   argp2 = (Dali::Actor *)jarg2;
40178   if (!argp2) {
40179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40180     return ;
40181   }
40182   arg2 = *argp2;
40183   argp3 = (Dali::Path *)jarg3;
40184   if (!argp3) {
40185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40186     return ;
40187   }
40188   arg3 = *argp3;
40189   arg4 = (Dali::Vector3 *)jarg4;
40190   if (!arg4) {
40191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40192     return ;
40193   }
40194   {
40195     try {
40196       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40197     } catch (std::out_of_range& e) {
40198       {
40199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40200       };
40201     } catch (std::exception& e) {
40202       {
40203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40204       };
40205     } catch (...) {
40206       {
40207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40208       };
40209     }
40210   }
40211 }
40212
40213
40214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40215   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40216   Dali::Actor arg2 ;
40217   Dali::Path arg3 ;
40218   Dali::Vector3 *arg4 = 0 ;
40219   Dali::AlphaFunction arg5 ;
40220   Dali::Actor *argp2 ;
40221   Dali::Path *argp3 ;
40222   Dali::AlphaFunction *argp5 ;
40223
40224   arg1 = (Dali::Animation *)jarg1;
40225   argp2 = (Dali::Actor *)jarg2;
40226   if (!argp2) {
40227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40228     return ;
40229   }
40230   arg2 = *argp2;
40231   argp3 = (Dali::Path *)jarg3;
40232   if (!argp3) {
40233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40234     return ;
40235   }
40236   arg3 = *argp3;
40237   arg4 = (Dali::Vector3 *)jarg4;
40238   if (!arg4) {
40239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40240     return ;
40241   }
40242   argp5 = (Dali::AlphaFunction *)jarg5;
40243   if (!argp5) {
40244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40245     return ;
40246   }
40247   arg5 = *argp5;
40248   {
40249     try {
40250       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40251     } catch (std::out_of_range& e) {
40252       {
40253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40254       };
40255     } catch (std::exception& e) {
40256       {
40257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40258       };
40259     } catch (...) {
40260       {
40261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40262       };
40263     }
40264   }
40265 }
40266
40267
40268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40269   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40270   Dali::Actor arg2 ;
40271   Dali::Path arg3 ;
40272   Dali::Vector3 *arg4 = 0 ;
40273   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40274   Dali::Actor *argp2 ;
40275   Dali::Path *argp3 ;
40276   Dali::TimePeriod *argp5 ;
40277
40278   arg1 = (Dali::Animation *)jarg1;
40279   argp2 = (Dali::Actor *)jarg2;
40280   if (!argp2) {
40281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40282     return ;
40283   }
40284   arg2 = *argp2;
40285   argp3 = (Dali::Path *)jarg3;
40286   if (!argp3) {
40287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40288     return ;
40289   }
40290   arg3 = *argp3;
40291   arg4 = (Dali::Vector3 *)jarg4;
40292   if (!arg4) {
40293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40294     return ;
40295   }
40296   argp5 = (Dali::TimePeriod *)jarg5;
40297   if (!argp5) {
40298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40299     return ;
40300   }
40301   arg5 = *argp5;
40302   {
40303     try {
40304       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40305     } catch (std::out_of_range& e) {
40306       {
40307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40308       };
40309     } catch (std::exception& e) {
40310       {
40311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40312       };
40313     } catch (...) {
40314       {
40315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40316       };
40317     }
40318   }
40319 }
40320
40321
40322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40323   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40324   Dali::Actor arg2 ;
40325   Dali::Path arg3 ;
40326   Dali::Vector3 *arg4 = 0 ;
40327   Dali::AlphaFunction arg5 ;
40328   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40329   Dali::Actor *argp2 ;
40330   Dali::Path *argp3 ;
40331   Dali::AlphaFunction *argp5 ;
40332   Dali::TimePeriod *argp6 ;
40333
40334   arg1 = (Dali::Animation *)jarg1;
40335   argp2 = (Dali::Actor *)jarg2;
40336   if (!argp2) {
40337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40338     return ;
40339   }
40340   arg2 = *argp2;
40341   argp3 = (Dali::Path *)jarg3;
40342   if (!argp3) {
40343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40344     return ;
40345   }
40346   arg3 = *argp3;
40347   arg4 = (Dali::Vector3 *)jarg4;
40348   if (!arg4) {
40349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40350     return ;
40351   }
40352   argp5 = (Dali::AlphaFunction *)jarg5;
40353   if (!argp5) {
40354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40355     return ;
40356   }
40357   arg5 = *argp5;
40358   argp6 = (Dali::TimePeriod *)jarg6;
40359   if (!argp6) {
40360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40361     return ;
40362   }
40363   arg6 = *argp6;
40364   {
40365     try {
40366       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40367     } catch (std::out_of_range& e) {
40368       {
40369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40370       };
40371     } catch (std::exception& e) {
40372       {
40373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40374       };
40375     } catch (...) {
40376       {
40377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40378       };
40379     }
40380   }
40381 }
40382
40383
40384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40385   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40386   Dali::Actor arg2 ;
40387   float arg3 ;
40388   Dali::Actor *argp2 ;
40389
40390   arg1 = (Dali::Animation *)jarg1;
40391   argp2 = (Dali::Actor *)jarg2;
40392   if (!argp2) {
40393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40394     return ;
40395   }
40396   arg2 = *argp2;
40397   arg3 = (float)jarg3;
40398   {
40399     try {
40400       (arg1)->Show(arg2,arg3);
40401     } catch (std::out_of_range& e) {
40402       {
40403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40404       };
40405     } catch (std::exception& e) {
40406       {
40407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40408       };
40409     } catch (...) {
40410       {
40411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40412       };
40413     }
40414   }
40415 }
40416
40417
40418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40419   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40420   Dali::Actor arg2 ;
40421   float arg3 ;
40422   Dali::Actor *argp2 ;
40423
40424   arg1 = (Dali::Animation *)jarg1;
40425   argp2 = (Dali::Actor *)jarg2;
40426   if (!argp2) {
40427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40428     return ;
40429   }
40430   arg2 = *argp2;
40431   arg3 = (float)jarg3;
40432   {
40433     try {
40434       (arg1)->Hide(arg2,arg3);
40435     } catch (std::out_of_range& e) {
40436       {
40437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40438       };
40439     } catch (std::exception& e) {
40440       {
40441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40442       };
40443     } catch (...) {
40444       {
40445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40446       };
40447     }
40448   }
40449 }
40450
40451
40452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40453   int jresult ;
40454   int result;
40455
40456   result = (int)Dali::LinearConstrainer::Property::VALUE;
40457   jresult = (int)result;
40458   return jresult;
40459 }
40460
40461
40462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40463   int jresult ;
40464   int result;
40465
40466   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40467   jresult = (int)result;
40468   return jresult;
40469 }
40470
40471
40472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40473   void * jresult ;
40474   Dali::LinearConstrainer::Property *result = 0 ;
40475
40476   {
40477     try {
40478       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40479     } catch (std::out_of_range& e) {
40480       {
40481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40482       };
40483     } catch (std::exception& e) {
40484       {
40485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40486       };
40487     } catch (...) {
40488       {
40489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40490       };
40491     }
40492   }
40493   jresult = (void *)result;
40494   return jresult;
40495 }
40496
40497
40498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40499   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40500
40501   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40502   {
40503     try {
40504       delete arg1;
40505     } catch (std::out_of_range& e) {
40506       {
40507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40508       };
40509     } catch (std::exception& e) {
40510       {
40511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40512       };
40513     } catch (...) {
40514       {
40515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40516       };
40517     }
40518   }
40519 }
40520
40521
40522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40523   void * jresult ;
40524   Dali::LinearConstrainer result;
40525
40526   {
40527     try {
40528       result = Dali::LinearConstrainer::New();
40529     } catch (std::out_of_range& e) {
40530       {
40531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40532       };
40533     } catch (std::exception& e) {
40534       {
40535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40540       };
40541     }
40542   }
40543   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40544   return jresult;
40545 }
40546
40547
40548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40549   void * jresult ;
40550   Dali::BaseHandle arg1 ;
40551   Dali::BaseHandle *argp1 ;
40552   Dali::LinearConstrainer result;
40553
40554   argp1 = (Dali::BaseHandle *)jarg1;
40555   if (!argp1) {
40556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40557     return 0;
40558   }
40559   arg1 = *argp1;
40560   {
40561     try {
40562       result = Dali::LinearConstrainer::DownCast(arg1);
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (...) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40574       };
40575     }
40576   }
40577   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40578   return jresult;
40579 }
40580
40581
40582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40583   void * jresult ;
40584   Dali::LinearConstrainer *result = 0 ;
40585
40586   {
40587     try {
40588       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40589     } catch (std::out_of_range& e) {
40590       {
40591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40592       };
40593     } catch (std::exception& e) {
40594       {
40595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40596       };
40597     } catch (...) {
40598       {
40599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40600       };
40601     }
40602   }
40603   jresult = (void *)result;
40604   return jresult;
40605 }
40606
40607
40608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40609   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40610
40611   arg1 = (Dali::LinearConstrainer *)jarg1;
40612   {
40613     try {
40614       delete arg1;
40615     } catch (std::out_of_range& e) {
40616       {
40617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40618       };
40619     } catch (std::exception& e) {
40620       {
40621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40622       };
40623     } catch (...) {
40624       {
40625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40626       };
40627     }
40628   }
40629 }
40630
40631
40632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40633   void * jresult ;
40634   Dali::LinearConstrainer *arg1 = 0 ;
40635   Dali::LinearConstrainer *result = 0 ;
40636
40637   arg1 = (Dali::LinearConstrainer *)jarg1;
40638   if (!arg1) {
40639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40640     return 0;
40641   }
40642   {
40643     try {
40644       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40645     } catch (std::out_of_range& e) {
40646       {
40647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40648       };
40649     } catch (std::exception& e) {
40650       {
40651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (...) {
40654       {
40655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40656       };
40657     }
40658   }
40659   jresult = (void *)result;
40660   return jresult;
40661 }
40662
40663
40664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40665   void * jresult ;
40666   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40667   Dali::LinearConstrainer *arg2 = 0 ;
40668   Dali::LinearConstrainer *result = 0 ;
40669
40670   arg1 = (Dali::LinearConstrainer *)jarg1;
40671   arg2 = (Dali::LinearConstrainer *)jarg2;
40672   if (!arg2) {
40673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40674     return 0;
40675   }
40676   {
40677     try {
40678       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40679     } catch (std::out_of_range& e) {
40680       {
40681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40682       };
40683     } catch (std::exception& e) {
40684       {
40685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40686       };
40687     } catch (...) {
40688       {
40689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40690       };
40691     }
40692   }
40693   jresult = (void *)result;
40694   return jresult;
40695 }
40696
40697
40698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40699   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40700   SwigValueWrapper< Dali::Property > arg2 ;
40701   SwigValueWrapper< Dali::Property > arg3 ;
40702   Dali::Vector2 *arg4 = 0 ;
40703   Dali::Vector2 *arg5 = 0 ;
40704   Dali::Property *argp2 ;
40705   Dali::Property *argp3 ;
40706
40707   arg1 = (Dali::LinearConstrainer *)jarg1;
40708   argp2 = (Dali::Property *)jarg2;
40709   if (!argp2) {
40710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40711     return ;
40712   }
40713   arg2 = *argp2;
40714   argp3 = (Dali::Property *)jarg3;
40715   if (!argp3) {
40716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40717     return ;
40718   }
40719   arg3 = *argp3;
40720   arg4 = (Dali::Vector2 *)jarg4;
40721   if (!arg4) {
40722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40723     return ;
40724   }
40725   arg5 = (Dali::Vector2 *)jarg5;
40726   if (!arg5) {
40727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40728     return ;
40729   }
40730   {
40731     try {
40732       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40733     } catch (std::out_of_range& e) {
40734       {
40735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40736       };
40737     } catch (std::exception& e) {
40738       {
40739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40740       };
40741     } catch (...) {
40742       {
40743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40744       };
40745     }
40746   }
40747 }
40748
40749
40750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40751   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40752   SwigValueWrapper< Dali::Property > arg2 ;
40753   SwigValueWrapper< Dali::Property > arg3 ;
40754   Dali::Vector2 *arg4 = 0 ;
40755   Dali::Property *argp2 ;
40756   Dali::Property *argp3 ;
40757
40758   arg1 = (Dali::LinearConstrainer *)jarg1;
40759   argp2 = (Dali::Property *)jarg2;
40760   if (!argp2) {
40761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40762     return ;
40763   }
40764   arg2 = *argp2;
40765   argp3 = (Dali::Property *)jarg3;
40766   if (!argp3) {
40767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40768     return ;
40769   }
40770   arg3 = *argp3;
40771   arg4 = (Dali::Vector2 *)jarg4;
40772   if (!arg4) {
40773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40774     return ;
40775   }
40776   {
40777     try {
40778       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40779     } catch (std::out_of_range& e) {
40780       {
40781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40782       };
40783     } catch (std::exception& e) {
40784       {
40785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40786       };
40787     } catch (...) {
40788       {
40789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40790       };
40791     }
40792   }
40793 }
40794
40795
40796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40797   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40798   Dali::Handle *arg2 = 0 ;
40799
40800   arg1 = (Dali::LinearConstrainer *)jarg1;
40801   arg2 = (Dali::Handle *)jarg2;
40802   if (!arg2) {
40803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40804     return ;
40805   }
40806   {
40807     try {
40808       (arg1)->Remove(*arg2);
40809     } catch (std::out_of_range& e) {
40810       {
40811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40812       };
40813     } catch (std::exception& e) {
40814       {
40815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40816       };
40817     } catch (...) {
40818       {
40819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40820       };
40821     }
40822   }
40823 }
40824
40825
40826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40827   int jresult ;
40828   int result;
40829
40830   result = (int)Dali::PathConstrainer::Property::FORWARD;
40831   jresult = (int)result;
40832   return jresult;
40833 }
40834
40835
40836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40837   int jresult ;
40838   int result;
40839
40840   result = (int)Dali::PathConstrainer::Property::POINTS;
40841   jresult = (int)result;
40842   return jresult;
40843 }
40844
40845
40846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40847   int jresult ;
40848   int result;
40849
40850   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40851   jresult = (int)result;
40852   return jresult;
40853 }
40854
40855
40856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40857   void * jresult ;
40858   Dali::PathConstrainer::Property *result = 0 ;
40859
40860   {
40861     try {
40862       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40870       };
40871     } catch (...) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40874       };
40875     }
40876   }
40877   jresult = (void *)result;
40878   return jresult;
40879 }
40880
40881
40882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40883   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40884
40885   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40886   {
40887     try {
40888       delete arg1;
40889     } catch (std::out_of_range& e) {
40890       {
40891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40892       };
40893     } catch (std::exception& e) {
40894       {
40895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40896       };
40897     } catch (...) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40900       };
40901     }
40902   }
40903 }
40904
40905
40906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40907   void * jresult ;
40908   Dali::PathConstrainer result;
40909
40910   {
40911     try {
40912       result = Dali::PathConstrainer::New();
40913     } catch (std::out_of_range& e) {
40914       {
40915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40916       };
40917     } catch (std::exception& e) {
40918       {
40919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40920       };
40921     } catch (...) {
40922       {
40923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40924       };
40925     }
40926   }
40927   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40928   return jresult;
40929 }
40930
40931
40932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40933   void * jresult ;
40934   Dali::BaseHandle arg1 ;
40935   Dali::BaseHandle *argp1 ;
40936   Dali::PathConstrainer result;
40937
40938   argp1 = (Dali::BaseHandle *)jarg1;
40939   if (!argp1) {
40940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40941     return 0;
40942   }
40943   arg1 = *argp1;
40944   {
40945     try {
40946       result = Dali::PathConstrainer::DownCast(arg1);
40947     } catch (std::out_of_range& e) {
40948       {
40949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40950       };
40951     } catch (std::exception& e) {
40952       {
40953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (...) {
40956       {
40957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40958       };
40959     }
40960   }
40961   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40962   return jresult;
40963 }
40964
40965
40966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40967   void * jresult ;
40968   Dali::PathConstrainer *result = 0 ;
40969
40970   {
40971     try {
40972       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40973     } catch (std::out_of_range& e) {
40974       {
40975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40976       };
40977     } catch (std::exception& e) {
40978       {
40979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40980       };
40981     } catch (...) {
40982       {
40983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40984       };
40985     }
40986   }
40987   jresult = (void *)result;
40988   return jresult;
40989 }
40990
40991
40992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40993   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40994
40995   arg1 = (Dali::PathConstrainer *)jarg1;
40996   {
40997     try {
40998       delete arg1;
40999     } catch (std::out_of_range& e) {
41000       {
41001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41002       };
41003     } catch (std::exception& e) {
41004       {
41005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41006       };
41007     } catch (...) {
41008       {
41009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41010       };
41011     }
41012   }
41013 }
41014
41015
41016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41017   void * jresult ;
41018   Dali::PathConstrainer *arg1 = 0 ;
41019   Dali::PathConstrainer *result = 0 ;
41020
41021   arg1 = (Dali::PathConstrainer *)jarg1;
41022   if (!arg1) {
41023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41024     return 0;
41025   }
41026   {
41027     try {
41028       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41029     } catch (std::out_of_range& e) {
41030       {
41031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41032       };
41033     } catch (std::exception& e) {
41034       {
41035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41036       };
41037     } catch (...) {
41038       {
41039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41040       };
41041     }
41042   }
41043   jresult = (void *)result;
41044   return jresult;
41045 }
41046
41047
41048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41049   void * jresult ;
41050   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41051   Dali::PathConstrainer *arg2 = 0 ;
41052   Dali::PathConstrainer *result = 0 ;
41053
41054   arg1 = (Dali::PathConstrainer *)jarg1;
41055   arg2 = (Dali::PathConstrainer *)jarg2;
41056   if (!arg2) {
41057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41058     return 0;
41059   }
41060   {
41061     try {
41062       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
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_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41083   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41084   SwigValueWrapper< Dali::Property > arg2 ;
41085   SwigValueWrapper< Dali::Property > arg3 ;
41086   Dali::Vector2 *arg4 = 0 ;
41087   Dali::Vector2 *arg5 = 0 ;
41088   Dali::Property *argp2 ;
41089   Dali::Property *argp3 ;
41090
41091   arg1 = (Dali::PathConstrainer *)jarg1;
41092   argp2 = (Dali::Property *)jarg2;
41093   if (!argp2) {
41094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41095     return ;
41096   }
41097   arg2 = *argp2;
41098   argp3 = (Dali::Property *)jarg3;
41099   if (!argp3) {
41100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41101     return ;
41102   }
41103   arg3 = *argp3;
41104   arg4 = (Dali::Vector2 *)jarg4;
41105   if (!arg4) {
41106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41107     return ;
41108   }
41109   arg5 = (Dali::Vector2 *)jarg5;
41110   if (!arg5) {
41111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41112     return ;
41113   }
41114   {
41115     try {
41116       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41117     } catch (std::out_of_range& e) {
41118       {
41119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41120       };
41121     } catch (std::exception& e) {
41122       {
41123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41124       };
41125     } catch (...) {
41126       {
41127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41128       };
41129     }
41130   }
41131 }
41132
41133
41134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41135   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41136   SwigValueWrapper< Dali::Property > arg2 ;
41137   SwigValueWrapper< Dali::Property > arg3 ;
41138   Dali::Vector2 *arg4 = 0 ;
41139   Dali::Property *argp2 ;
41140   Dali::Property *argp3 ;
41141
41142   arg1 = (Dali::PathConstrainer *)jarg1;
41143   argp2 = (Dali::Property *)jarg2;
41144   if (!argp2) {
41145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41146     return ;
41147   }
41148   arg2 = *argp2;
41149   argp3 = (Dali::Property *)jarg3;
41150   if (!argp3) {
41151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41152     return ;
41153   }
41154   arg3 = *argp3;
41155   arg4 = (Dali::Vector2 *)jarg4;
41156   if (!arg4) {
41157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41158     return ;
41159   }
41160   {
41161     try {
41162       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41163     } catch (std::out_of_range& e) {
41164       {
41165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41166       };
41167     } catch (std::exception& e) {
41168       {
41169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41170       };
41171     } catch (...) {
41172       {
41173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41174       };
41175     }
41176   }
41177 }
41178
41179
41180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41181   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41182   Dali::Handle *arg2 = 0 ;
41183
41184   arg1 = (Dali::PathConstrainer *)jarg1;
41185   arg2 = (Dali::Handle *)jarg2;
41186   if (!arg2) {
41187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41188     return ;
41189   }
41190   {
41191     try {
41192       (arg1)->Remove(*arg2);
41193     } catch (std::out_of_range& e) {
41194       {
41195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41196       };
41197     } catch (std::exception& e) {
41198       {
41199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41200       };
41201     } catch (...) {
41202       {
41203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41204       };
41205     }
41206   }
41207 }
41208
41209
41210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41211   int jresult ;
41212   Dali::FittingMode::Type result;
41213
41214   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41215   jresult = (int)result;
41216   return jresult;
41217 }
41218
41219
41220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41221   int jresult ;
41222   Dali::SamplingMode::Type result;
41223
41224   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41225   jresult = (int)result;
41226   return jresult;
41227 }
41228
41229
41230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41231   void * jresult ;
41232   Dali::BufferImage *result = 0 ;
41233
41234   {
41235     try {
41236       result = (Dali::BufferImage *)new Dali::BufferImage();
41237     } catch (std::out_of_range& e) {
41238       {
41239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41240       };
41241     } catch (std::exception& e) {
41242       {
41243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41244       };
41245     } catch (...) {
41246       {
41247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41248       };
41249     }
41250   }
41251   jresult = (void *)result;
41252   return jresult;
41253 }
41254
41255
41256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41257   void * jresult ;
41258   unsigned int arg1 ;
41259   unsigned int arg2 ;
41260   Dali::Pixel::Format arg3 ;
41261   Dali::BufferImage result;
41262
41263   arg1 = (unsigned int)jarg1;
41264   arg2 = (unsigned int)jarg2;
41265   arg3 = (Dali::Pixel::Format)jarg3;
41266   {
41267     try {
41268       result = Dali::BufferImage::New(arg1,arg2,arg3);
41269     } catch (std::out_of_range& e) {
41270       {
41271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41272       };
41273     } catch (std::exception& e) {
41274       {
41275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41276       };
41277     } catch (...) {
41278       {
41279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41280       };
41281     }
41282   }
41283   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41284   return jresult;
41285 }
41286
41287
41288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41289   void * jresult ;
41290   unsigned int arg1 ;
41291   unsigned int arg2 ;
41292   Dali::BufferImage result;
41293
41294   arg1 = (unsigned int)jarg1;
41295   arg2 = (unsigned int)jarg2;
41296   {
41297     try {
41298       result = Dali::BufferImage::New(arg1,arg2);
41299     } catch (std::out_of_range& e) {
41300       {
41301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41302       };
41303     } catch (std::exception& e) {
41304       {
41305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41306       };
41307     } catch (...) {
41308       {
41309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41310       };
41311     }
41312   }
41313   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41314   return jresult;
41315 }
41316
41317
41318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41319   void * jresult ;
41320   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41321   unsigned int arg2 ;
41322   unsigned int arg3 ;
41323   Dali::Pixel::Format arg4 ;
41324   unsigned int arg5 ;
41325   Dali::BufferImage result;
41326
41327   arg1 = jarg1;
41328   arg2 = (unsigned int)jarg2;
41329   arg3 = (unsigned int)jarg3;
41330   arg4 = (Dali::Pixel::Format)jarg4;
41331   arg5 = (unsigned int)jarg5;
41332   {
41333     try {
41334       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41335     } catch (std::out_of_range& e) {
41336       {
41337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41338       };
41339     } catch (std::exception& e) {
41340       {
41341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (...) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41346       };
41347     }
41348   }
41349   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41350
41351
41352   return jresult;
41353 }
41354
41355
41356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41357   void * jresult ;
41358   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41359   unsigned int arg2 ;
41360   unsigned int arg3 ;
41361   Dali::Pixel::Format arg4 ;
41362   Dali::BufferImage result;
41363
41364   arg1 = jarg1;
41365   arg2 = (unsigned int)jarg2;
41366   arg3 = (unsigned int)jarg3;
41367   arg4 = (Dali::Pixel::Format)jarg4;
41368   {
41369     try {
41370       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41371     } catch (std::out_of_range& e) {
41372       {
41373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41374       };
41375     } catch (std::exception& e) {
41376       {
41377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41378       };
41379     } catch (...) {
41380       {
41381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41382       };
41383     }
41384   }
41385   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41386
41387
41388   return jresult;
41389 }
41390
41391
41392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41393   void * jresult ;
41394   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41395   unsigned int arg2 ;
41396   unsigned int arg3 ;
41397   Dali::BufferImage result;
41398
41399   arg1 = jarg1;
41400   arg2 = (unsigned int)jarg2;
41401   arg3 = (unsigned int)jarg3;
41402   {
41403     try {
41404       result = Dali::BufferImage::New(arg1,arg2,arg3);
41405     } catch (std::out_of_range& e) {
41406       {
41407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41408       };
41409     } catch (std::exception& e) {
41410       {
41411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41412       };
41413     } catch (...) {
41414       {
41415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41416       };
41417     }
41418   }
41419   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41420
41421
41422   return jresult;
41423 }
41424
41425
41426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41427   void * jresult ;
41428   Dali::BaseHandle arg1 ;
41429   Dali::BaseHandle *argp1 ;
41430   Dali::BufferImage result;
41431
41432   argp1 = (Dali::BaseHandle *)jarg1;
41433   if (!argp1) {
41434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41435     return 0;
41436   }
41437   arg1 = *argp1;
41438   {
41439     try {
41440       result = Dali::BufferImage::DownCast(arg1);
41441     } catch (std::out_of_range& e) {
41442       {
41443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41444       };
41445     } catch (std::exception& e) {
41446       {
41447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41448       };
41449     } catch (...) {
41450       {
41451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41452       };
41453     }
41454   }
41455   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41456   return jresult;
41457 }
41458
41459
41460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41461   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41462
41463   arg1 = (Dali::BufferImage *)jarg1;
41464   {
41465     try {
41466       delete arg1;
41467     } catch (std::out_of_range& e) {
41468       {
41469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41470       };
41471     } catch (std::exception& e) {
41472       {
41473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41474       };
41475     } catch (...) {
41476       {
41477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41478       };
41479     }
41480   }
41481 }
41482
41483
41484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41485   void * jresult ;
41486   Dali::BufferImage *arg1 = 0 ;
41487   Dali::BufferImage *result = 0 ;
41488
41489   arg1 = (Dali::BufferImage *)jarg1;
41490   if (!arg1) {
41491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41492     return 0;
41493   }
41494   {
41495     try {
41496       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41497     } catch (std::out_of_range& e) {
41498       {
41499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41500       };
41501     } catch (std::exception& e) {
41502       {
41503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41504       };
41505     } catch (...) {
41506       {
41507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41508       };
41509     }
41510   }
41511   jresult = (void *)result;
41512   return jresult;
41513 }
41514
41515
41516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41517   void * jresult ;
41518   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41519   Dali::BufferImage *arg2 = 0 ;
41520   Dali::BufferImage *result = 0 ;
41521
41522   arg1 = (Dali::BufferImage *)jarg1;
41523   arg2 = (Dali::BufferImage *)jarg2;
41524   if (!arg2) {
41525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41526     return 0;
41527   }
41528   {
41529     try {
41530       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41531     } catch (std::out_of_range& e) {
41532       {
41533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41534       };
41535     } catch (std::exception& e) {
41536       {
41537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41538       };
41539     } catch (...) {
41540       {
41541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41542       };
41543     }
41544   }
41545   jresult = (void *)result;
41546   return jresult;
41547 }
41548
41549
41550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41551   void * jresult ;
41552   Dali::BufferImage result;
41553
41554   {
41555     try {
41556       result = Dali::BufferImage::WHITE();
41557     } catch (std::out_of_range& e) {
41558       {
41559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41560       };
41561     } catch (std::exception& e) {
41562       {
41563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41564       };
41565     } catch (...) {
41566       {
41567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41568       };
41569     }
41570   }
41571   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41572   return jresult;
41573 }
41574
41575
41576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41577   void * jresult ;
41578   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41579   Dali::PixelBuffer *result = 0 ;
41580
41581   arg1 = (Dali::BufferImage *)jarg1;
41582   {
41583     try {
41584       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41585     } catch (std::out_of_range& e) {
41586       {
41587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41588       };
41589     } catch (std::exception& e) {
41590       {
41591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41592       };
41593     } catch (...) {
41594       {
41595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41596       };
41597     }
41598   }
41599   jresult = (void *)result;
41600   return jresult;
41601 }
41602
41603
41604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41605   unsigned int jresult ;
41606   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41607   unsigned int result;
41608
41609   arg1 = (Dali::BufferImage *)jarg1;
41610   {
41611     try {
41612       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41613     } catch (std::out_of_range& e) {
41614       {
41615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41616       };
41617     } catch (std::exception& e) {
41618       {
41619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41620       };
41621     } catch (...) {
41622       {
41623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41624       };
41625     }
41626   }
41627   jresult = result;
41628   return jresult;
41629 }
41630
41631
41632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41633   unsigned int jresult ;
41634   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41635   unsigned int result;
41636
41637   arg1 = (Dali::BufferImage *)jarg1;
41638   {
41639     try {
41640       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41641     } catch (std::out_of_range& e) {
41642       {
41643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41644       };
41645     } catch (std::exception& e) {
41646       {
41647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41648       };
41649     } catch (...) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41652       };
41653     }
41654   }
41655   jresult = result;
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41661   int jresult ;
41662   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41663   Dali::Pixel::Format result;
41664
41665   arg1 = (Dali::BufferImage *)jarg1;
41666   {
41667     try {
41668       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41669     } catch (std::out_of_range& e) {
41670       {
41671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41672       };
41673     } catch (std::exception& e) {
41674       {
41675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41676       };
41677     } catch (...) {
41678       {
41679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41680       };
41681     }
41682   }
41683   jresult = (int)result;
41684   return jresult;
41685 }
41686
41687
41688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41689   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41690
41691   arg1 = (Dali::BufferImage *)jarg1;
41692   {
41693     try {
41694       (arg1)->Update();
41695     } catch (std::out_of_range& e) {
41696       {
41697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41698       };
41699     } catch (std::exception& e) {
41700       {
41701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41702       };
41703     } catch (...) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41706       };
41707     }
41708   }
41709 }
41710
41711
41712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41713   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41714   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41715   Dali::RectArea *argp2 ;
41716
41717   arg1 = (Dali::BufferImage *)jarg1;
41718   argp2 = (Dali::RectArea *)jarg2;
41719   if (!argp2) {
41720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41721     return ;
41722   }
41723   arg2 = *argp2;
41724   {
41725     try {
41726       (arg1)->Update(arg2);
41727     } catch (std::out_of_range& e) {
41728       {
41729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41730       };
41731     } catch (std::exception& e) {
41732       {
41733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41734       };
41735     } catch (...) {
41736       {
41737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41738       };
41739     }
41740   }
41741 }
41742
41743
41744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41745   unsigned int jresult ;
41746   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41747   bool result;
41748
41749   arg1 = (Dali::BufferImage *)jarg1;
41750   {
41751     try {
41752       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (...) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41764       };
41765     }
41766   }
41767   jresult = result;
41768   return jresult;
41769 }
41770
41771
41772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41773   void * jresult ;
41774   Dali::EncodedBufferImage *result = 0 ;
41775
41776   {
41777     try {
41778       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41779     } catch (std::out_of_range& e) {
41780       {
41781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41782       };
41783     } catch (std::exception& e) {
41784       {
41785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (...) {
41788       {
41789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41790       };
41791     }
41792   }
41793   jresult = (void *)result;
41794   return jresult;
41795 }
41796
41797
41798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41799   void * jresult ;
41800   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41801   std::size_t arg2 ;
41802   Dali::EncodedBufferImage result;
41803
41804   arg1 = (uint8_t *)jarg1;
41805   arg2 = (std::size_t)jarg2;
41806   {
41807     try {
41808       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41809     } catch (std::out_of_range& e) {
41810       {
41811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41812       };
41813     } catch (std::exception& e) {
41814       {
41815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41816       };
41817     } catch (...) {
41818       {
41819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41820       };
41821     }
41822   }
41823   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41824   return jresult;
41825 }
41826
41827
41828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41829   void * jresult ;
41830   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41831   std::size_t arg2 ;
41832   Dali::ImageDimensions arg3 ;
41833   Dali::FittingMode::Type arg4 ;
41834   Dali::SamplingMode::Type arg5 ;
41835   bool arg6 ;
41836   Dali::ImageDimensions *argp3 ;
41837   Dali::EncodedBufferImage result;
41838
41839   arg1 = (uint8_t *)jarg1;
41840   arg2 = (std::size_t)jarg2;
41841   argp3 = (Dali::ImageDimensions *)jarg3;
41842   if (!argp3) {
41843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41844     return 0;
41845   }
41846   arg3 = *argp3;
41847   arg4 = (Dali::FittingMode::Type)jarg4;
41848   arg5 = (Dali::SamplingMode::Type)jarg5;
41849   arg6 = jarg6 ? true : false;
41850   {
41851     try {
41852       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41853     } catch (std::out_of_range& e) {
41854       {
41855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41856       };
41857     } catch (std::exception& e) {
41858       {
41859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41860       };
41861     } catch (...) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41864       };
41865     }
41866   }
41867   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41868   return jresult;
41869 }
41870
41871
41872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41873   void * jresult ;
41874   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41875   std::size_t arg2 ;
41876   Dali::ImageDimensions arg3 ;
41877   Dali::FittingMode::Type arg4 ;
41878   Dali::SamplingMode::Type arg5 ;
41879   Dali::ImageDimensions *argp3 ;
41880   Dali::EncodedBufferImage result;
41881
41882   arg1 = (uint8_t *)jarg1;
41883   arg2 = (std::size_t)jarg2;
41884   argp3 = (Dali::ImageDimensions *)jarg3;
41885   if (!argp3) {
41886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41887     return 0;
41888   }
41889   arg3 = *argp3;
41890   arg4 = (Dali::FittingMode::Type)jarg4;
41891   arg5 = (Dali::SamplingMode::Type)jarg5;
41892   {
41893     try {
41894       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41895     } catch (std::out_of_range& e) {
41896       {
41897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41898       };
41899     } catch (std::exception& e) {
41900       {
41901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41902       };
41903     } catch (...) {
41904       {
41905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41906       };
41907     }
41908   }
41909   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41910   return jresult;
41911 }
41912
41913
41914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41915   void * jresult ;
41916   Dali::BaseHandle arg1 ;
41917   Dali::BaseHandle *argp1 ;
41918   Dali::EncodedBufferImage result;
41919
41920   argp1 = (Dali::BaseHandle *)jarg1;
41921   if (!argp1) {
41922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41923     return 0;
41924   }
41925   arg1 = *argp1;
41926   {
41927     try {
41928       result = Dali::EncodedBufferImage::DownCast(arg1);
41929     } catch (std::out_of_range& e) {
41930       {
41931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41932       };
41933     } catch (std::exception& e) {
41934       {
41935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41936       };
41937     } catch (...) {
41938       {
41939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41940       };
41941     }
41942   }
41943   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41944   return jresult;
41945 }
41946
41947
41948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41949   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41950
41951   arg1 = (Dali::EncodedBufferImage *)jarg1;
41952   {
41953     try {
41954       delete arg1;
41955     } catch (std::out_of_range& e) {
41956       {
41957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41958       };
41959     } catch (std::exception& e) {
41960       {
41961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41962       };
41963     } catch (...) {
41964       {
41965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41966       };
41967     }
41968   }
41969 }
41970
41971
41972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41973   void * jresult ;
41974   Dali::EncodedBufferImage *arg1 = 0 ;
41975   Dali::EncodedBufferImage *result = 0 ;
41976
41977   arg1 = (Dali::EncodedBufferImage *)jarg1;
41978   if (!arg1) {
41979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41980     return 0;
41981   }
41982   {
41983     try {
41984       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41985     } catch (std::out_of_range& e) {
41986       {
41987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41988       };
41989     } catch (std::exception& e) {
41990       {
41991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41992       };
41993     } catch (...) {
41994       {
41995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41996       };
41997     }
41998   }
41999   jresult = (void *)result;
42000   return jresult;
42001 }
42002
42003
42004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42005   void * jresult ;
42006   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42007   Dali::EncodedBufferImage *arg2 = 0 ;
42008   Dali::EncodedBufferImage *result = 0 ;
42009
42010   arg1 = (Dali::EncodedBufferImage *)jarg1;
42011   arg2 = (Dali::EncodedBufferImage *)jarg2;
42012   if (!arg2) {
42013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42014     return 0;
42015   }
42016   {
42017     try {
42018       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42019     } catch (std::out_of_range& e) {
42020       {
42021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42022       };
42023     } catch (std::exception& e) {
42024       {
42025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42026       };
42027     } catch (...) {
42028       {
42029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42030       };
42031     }
42032   }
42033   jresult = (void *)result;
42034   return jresult;
42035 }
42036
42037
42038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42039   void * jresult ;
42040   Dali::NativeImage *result = 0 ;
42041
42042   {
42043     try {
42044       result = (Dali::NativeImage *)new Dali::NativeImage();
42045     } catch (std::out_of_range& e) {
42046       {
42047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42048       };
42049     } catch (std::exception& e) {
42050       {
42051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42052       };
42053     } catch (...) {
42054       {
42055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42056       };
42057     }
42058   }
42059   jresult = (void *)result;
42060   return jresult;
42061 }
42062
42063
42064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42065   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42066
42067   arg1 = (Dali::NativeImage *)jarg1;
42068   {
42069     try {
42070       delete arg1;
42071     } catch (std::out_of_range& e) {
42072       {
42073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42074       };
42075     } catch (std::exception& e) {
42076       {
42077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42078       };
42079     } catch (...) {
42080       {
42081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42082       };
42083     }
42084   }
42085 }
42086
42087
42088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42089   void * jresult ;
42090   Dali::NativeImage *arg1 = 0 ;
42091   Dali::NativeImage *result = 0 ;
42092
42093   arg1 = (Dali::NativeImage *)jarg1;
42094   if (!arg1) {
42095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42096     return 0;
42097   }
42098   {
42099     try {
42100       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42101     } catch (std::out_of_range& e) {
42102       {
42103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42104       };
42105     } catch (std::exception& e) {
42106       {
42107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42108       };
42109     } catch (...) {
42110       {
42111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42112       };
42113     }
42114   }
42115   jresult = (void *)result;
42116   return jresult;
42117 }
42118
42119
42120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42121   void * jresult ;
42122   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42123   Dali::NativeImage *arg2 = 0 ;
42124   Dali::NativeImage *result = 0 ;
42125
42126   arg1 = (Dali::NativeImage *)jarg1;
42127   arg2 = (Dali::NativeImage *)jarg2;
42128   if (!arg2) {
42129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42130     return 0;
42131   }
42132   {
42133     try {
42134       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
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 = (void *)result;
42150   return jresult;
42151 }
42152
42153
42154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42155   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42156
42157   arg1 = (Dali::NativeImage *)jarg1;
42158   {
42159     try {
42160       (arg1)->CreateGlTexture();
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 void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42179   void * jresult ;
42180   NativeImageInterface *arg1 = 0 ;
42181   Dali::NativeImage result;
42182
42183   arg1 = (NativeImageInterface *)jarg1;
42184   if (!arg1) {
42185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42186     return 0;
42187   }
42188   {
42189     try {
42190       result = Dali::NativeImage::New(*arg1);
42191     } catch (std::out_of_range& e) {
42192       {
42193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42194       };
42195     } catch (std::exception& e) {
42196       {
42197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42198       };
42199     } catch (...) {
42200       {
42201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42202       };
42203     }
42204   }
42205   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42206   return jresult;
42207 }
42208
42209
42210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42211   void * jresult ;
42212   Dali::BaseHandle arg1 ;
42213   Dali::BaseHandle *argp1 ;
42214   Dali::NativeImage result;
42215
42216   argp1 = (Dali::BaseHandle *)jarg1;
42217   if (!argp1) {
42218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42219     return 0;
42220   }
42221   arg1 = *argp1;
42222   {
42223     try {
42224       result = Dali::NativeImage::DownCast(arg1);
42225     } catch (std::out_of_range& e) {
42226       {
42227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42228       };
42229     } catch (std::exception& e) {
42230       {
42231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42232       };
42233     } catch (...) {
42234       {
42235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42236       };
42237     }
42238   }
42239   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42240   return jresult;
42241 }
42242
42243
42244 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42245   char * jresult ;
42246   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42247   char *result = 0 ;
42248
42249   arg1 = (Dali::NativeImage *)jarg1;
42250   {
42251     try {
42252       result = (char *)(arg1)->GetCustomFragmentPreFix();
42253     } catch (std::out_of_range& e) {
42254       {
42255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42256       };
42257     } catch (std::exception& e) {
42258       {
42259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42260       };
42261     } catch (...) {
42262       {
42263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42264       };
42265     }
42266   }
42267   jresult = SWIG_csharp_string_callback((const char *)result);
42268   return jresult;
42269 }
42270
42271
42272 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42273   char * jresult ;
42274   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42275   char *result = 0 ;
42276
42277   arg1 = (Dali::NativeImage *)jarg1;
42278   {
42279     try {
42280       result = (char *)(arg1)->GetCustomSamplerTypename();
42281     } catch (std::out_of_range& e) {
42282       {
42283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42284       };
42285     } catch (std::exception& e) {
42286       {
42287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42288       };
42289     } catch (...) {
42290       {
42291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42292       };
42293     }
42294   }
42295   jresult = SWIG_csharp_string_callback((const char *)result);
42296   return jresult;
42297 }
42298
42299
42300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42301   unsigned int jresult ;
42302   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42303   bool result;
42304
42305   arg1 = (Dali::NativeImageInterface *)jarg1;
42306   {
42307     try {
42308       result = (bool)(arg1)->GlExtensionCreate();
42309     } catch (std::out_of_range& e) {
42310       {
42311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42312       };
42313     } catch (std::exception& e) {
42314       {
42315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (...) {
42318       {
42319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42320       };
42321     }
42322   }
42323   jresult = result;
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42329   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42330
42331   arg1 = (Dali::NativeImageInterface *)jarg1;
42332   {
42333     try {
42334       (arg1)->GlExtensionDestroy();
42335     } catch (std::out_of_range& e) {
42336       {
42337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42338       };
42339     } catch (std::exception& e) {
42340       {
42341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42342       };
42343     } catch (...) {
42344       {
42345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42346       };
42347     }
42348   }
42349 }
42350
42351
42352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42353   unsigned int jresult ;
42354   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42355   unsigned int result;
42356
42357   arg1 = (Dali::NativeImageInterface *)jarg1;
42358   {
42359     try {
42360       result = (unsigned int)(arg1)->TargetTexture();
42361     } catch (std::out_of_range& e) {
42362       {
42363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42364       };
42365     } catch (std::exception& e) {
42366       {
42367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (...) {
42370       {
42371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42372       };
42373     }
42374   }
42375   jresult = result;
42376   return jresult;
42377 }
42378
42379
42380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42381   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42382
42383   arg1 = (Dali::NativeImageInterface *)jarg1;
42384   {
42385     try {
42386       (arg1)->PrepareTexture();
42387     } catch (std::out_of_range& e) {
42388       {
42389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42390       };
42391     } catch (std::exception& e) {
42392       {
42393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42394       };
42395     } catch (...) {
42396       {
42397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42398       };
42399     }
42400   }
42401 }
42402
42403
42404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42405   unsigned int jresult ;
42406   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42407   unsigned int result;
42408
42409   arg1 = (Dali::NativeImageInterface *)jarg1;
42410   {
42411     try {
42412       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
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 = result;
42428   return jresult;
42429 }
42430
42431
42432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42433   unsigned int jresult ;
42434   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42435   unsigned int result;
42436
42437   arg1 = (Dali::NativeImageInterface *)jarg1;
42438   {
42439     try {
42440       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42441     } catch (std::out_of_range& e) {
42442       {
42443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42444       };
42445     } catch (std::exception& e) {
42446       {
42447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42448       };
42449     } catch (...) {
42450       {
42451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42452       };
42453     }
42454   }
42455   jresult = result;
42456   return jresult;
42457 }
42458
42459
42460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42461   unsigned int jresult ;
42462   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42463   bool result;
42464
42465   arg1 = (Dali::NativeImageInterface *)jarg1;
42466   {
42467     try {
42468       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42469     } catch (std::out_of_range& e) {
42470       {
42471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42472       };
42473     } catch (std::exception& e) {
42474       {
42475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42476       };
42477     } catch (...) {
42478       {
42479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42480       };
42481     }
42482   }
42483   jresult = result;
42484   return jresult;
42485 }
42486
42487
42488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42489   void * jresult ;
42490   std::string *arg1 = 0 ;
42491   Dali::ImageDimensions result;
42492
42493   if (!jarg1) {
42494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42495     return 0;
42496   }
42497   std::string arg1_str(jarg1);
42498   arg1 = &arg1_str;
42499   {
42500     try {
42501       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42502     } catch (std::out_of_range& e) {
42503       {
42504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42505       };
42506     } catch (std::exception& e) {
42507       {
42508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42509       };
42510     } catch (...) {
42511       {
42512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42513       };
42514     }
42515   }
42516   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42517
42518   //argout typemap for const std::string&
42519
42520   return jresult;
42521 }
42522
42523
42524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42525   void * jresult ;
42526   Dali::ResourceImage *result = 0 ;
42527
42528   {
42529     try {
42530       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42531     } catch (std::out_of_range& e) {
42532       {
42533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (std::exception& e) {
42536       {
42537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42538       };
42539     } catch (...) {
42540       {
42541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42542       };
42543     }
42544   }
42545   jresult = (void *)result;
42546   return jresult;
42547 }
42548
42549
42550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42551   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42552
42553   arg1 = (Dali::ResourceImage *)jarg1;
42554   {
42555     try {
42556       delete arg1;
42557     } catch (std::out_of_range& e) {
42558       {
42559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42560       };
42561     } catch (std::exception& e) {
42562       {
42563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42564       };
42565     } catch (...) {
42566       {
42567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42568       };
42569     }
42570   }
42571 }
42572
42573
42574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42575   void * jresult ;
42576   Dali::ResourceImage *arg1 = 0 ;
42577   Dali::ResourceImage *result = 0 ;
42578
42579   arg1 = (Dali::ResourceImage *)jarg1;
42580   if (!arg1) {
42581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42582     return 0;
42583   }
42584   {
42585     try {
42586       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42587     } catch (std::out_of_range& e) {
42588       {
42589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42590       };
42591     } catch (std::exception& e) {
42592       {
42593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (...) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42598       };
42599     }
42600   }
42601   jresult = (void *)result;
42602   return jresult;
42603 }
42604
42605
42606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42607   void * jresult ;
42608   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42609   Dali::ResourceImage *arg2 = 0 ;
42610   Dali::ResourceImage *result = 0 ;
42611
42612   arg1 = (Dali::ResourceImage *)jarg1;
42613   arg2 = (Dali::ResourceImage *)jarg2;
42614   if (!arg2) {
42615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42616     return 0;
42617   }
42618   {
42619     try {
42620       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42621     } catch (std::out_of_range& e) {
42622       {
42623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42624       };
42625     } catch (std::exception& e) {
42626       {
42627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42628       };
42629     } catch (...) {
42630       {
42631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42632       };
42633     }
42634   }
42635   jresult = (void *)result;
42636   return jresult;
42637 }
42638
42639
42640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42641   void * jresult ;
42642   std::string *arg1 = 0 ;
42643   bool arg2 ;
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   arg2 = jarg2 ? true : false;
42653   {
42654     try {
42655       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42656     } catch (std::out_of_range& e) {
42657       {
42658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42659       };
42660     } catch (std::exception& e) {
42661       {
42662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42663       };
42664     } catch (...) {
42665       {
42666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42667       };
42668     }
42669   }
42670   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42671
42672   //argout typemap for const std::string&
42673
42674   return jresult;
42675 }
42676
42677
42678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42679   void * jresult ;
42680   std::string *arg1 = 0 ;
42681   Dali::ResourceImage result;
42682
42683   if (!jarg1) {
42684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42685     return 0;
42686   }
42687   std::string arg1_str(jarg1);
42688   arg1 = &arg1_str;
42689   {
42690     try {
42691       result = Dali::ResourceImage::New((std::string const &)*arg1);
42692     } catch (std::out_of_range& e) {
42693       {
42694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42695       };
42696     } catch (std::exception& e) {
42697       {
42698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42699       };
42700     } catch (...) {
42701       {
42702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42703       };
42704     }
42705   }
42706   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42707
42708   //argout typemap for const std::string&
42709
42710   return jresult;
42711 }
42712
42713
42714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42715   void * jresult ;
42716   std::string *arg1 = 0 ;
42717   Dali::ImageDimensions arg2 ;
42718   Dali::FittingMode::Type arg3 ;
42719   Dali::SamplingMode::Type arg4 ;
42720   bool arg5 ;
42721   Dali::ImageDimensions *argp2 ;
42722   Dali::ResourceImage result;
42723
42724   if (!jarg1) {
42725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42726     return 0;
42727   }
42728   std::string arg1_str(jarg1);
42729   arg1 = &arg1_str;
42730   argp2 = (Dali::ImageDimensions *)jarg2;
42731   if (!argp2) {
42732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42733     return 0;
42734   }
42735   arg2 = *argp2;
42736   arg3 = (Dali::FittingMode::Type)jarg3;
42737   arg4 = (Dali::SamplingMode::Type)jarg4;
42738   arg5 = jarg5 ? true : false;
42739   {
42740     try {
42741       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42742     } catch (std::out_of_range& e) {
42743       {
42744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42745       };
42746     } catch (std::exception& e) {
42747       {
42748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42749       };
42750     } catch (...) {
42751       {
42752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42753       };
42754     }
42755   }
42756   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42757
42758   //argout typemap for const std::string&
42759
42760   return jresult;
42761 }
42762
42763
42764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42765   void * jresult ;
42766   std::string *arg1 = 0 ;
42767   Dali::ImageDimensions arg2 ;
42768   Dali::FittingMode::Type arg3 ;
42769   Dali::SamplingMode::Type arg4 ;
42770   Dali::ImageDimensions *argp2 ;
42771   Dali::ResourceImage result;
42772
42773   if (!jarg1) {
42774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42775     return 0;
42776   }
42777   std::string arg1_str(jarg1);
42778   arg1 = &arg1_str;
42779   argp2 = (Dali::ImageDimensions *)jarg2;
42780   if (!argp2) {
42781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42782     return 0;
42783   }
42784   arg2 = *argp2;
42785   arg3 = (Dali::FittingMode::Type)jarg3;
42786   arg4 = (Dali::SamplingMode::Type)jarg4;
42787   {
42788     try {
42789       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42790     } catch (std::out_of_range& e) {
42791       {
42792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42793       };
42794     } catch (std::exception& e) {
42795       {
42796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42797       };
42798     } catch (...) {
42799       {
42800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42801       };
42802     }
42803   }
42804   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42805
42806   //argout typemap for const std::string&
42807
42808   return jresult;
42809 }
42810
42811
42812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42813   void * jresult ;
42814   std::string *arg1 = 0 ;
42815   Dali::ImageDimensions arg2 ;
42816   Dali::FittingMode::Type arg3 ;
42817   Dali::ImageDimensions *argp2 ;
42818   Dali::ResourceImage result;
42819
42820   if (!jarg1) {
42821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42822     return 0;
42823   }
42824   std::string arg1_str(jarg1);
42825   arg1 = &arg1_str;
42826   argp2 = (Dali::ImageDimensions *)jarg2;
42827   if (!argp2) {
42828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42829     return 0;
42830   }
42831   arg2 = *argp2;
42832   arg3 = (Dali::FittingMode::Type)jarg3;
42833   {
42834     try {
42835       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42836     } catch (std::out_of_range& e) {
42837       {
42838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42839       };
42840     } catch (std::exception& e) {
42841       {
42842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42843       };
42844     } catch (...) {
42845       {
42846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42847       };
42848     }
42849   }
42850   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42851
42852   //argout typemap for const std::string&
42853
42854   return jresult;
42855 }
42856
42857
42858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42859   void * jresult ;
42860   std::string *arg1 = 0 ;
42861   Dali::ImageDimensions arg2 ;
42862   Dali::ImageDimensions *argp2 ;
42863   Dali::ResourceImage result;
42864
42865   if (!jarg1) {
42866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42867     return 0;
42868   }
42869   std::string arg1_str(jarg1);
42870   arg1 = &arg1_str;
42871   argp2 = (Dali::ImageDimensions *)jarg2;
42872   if (!argp2) {
42873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42874     return 0;
42875   }
42876   arg2 = *argp2;
42877   {
42878     try {
42879       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42880     } catch (std::out_of_range& e) {
42881       {
42882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42883       };
42884     } catch (std::exception& e) {
42885       {
42886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (...) {
42889       {
42890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42891       };
42892     }
42893   }
42894   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42895
42896   //argout typemap for const std::string&
42897
42898   return jresult;
42899 }
42900
42901
42902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42903   void * jresult ;
42904   Dali::BaseHandle arg1 ;
42905   Dali::BaseHandle *argp1 ;
42906   Dali::ResourceImage result;
42907
42908   argp1 = (Dali::BaseHandle *)jarg1;
42909   if (!argp1) {
42910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42911     return 0;
42912   }
42913   arg1 = *argp1;
42914   {
42915     try {
42916       result = Dali::ResourceImage::DownCast(arg1);
42917     } catch (std::out_of_range& e) {
42918       {
42919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42920       };
42921     } catch (std::exception& e) {
42922       {
42923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42924       };
42925     } catch (...) {
42926       {
42927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42928       };
42929     }
42930   }
42931   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42932   return jresult;
42933 }
42934
42935
42936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42937   int jresult ;
42938   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42939   Dali::LoadingState result;
42940
42941   arg1 = (Dali::ResourceImage *)jarg1;
42942   {
42943     try {
42944       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42945     } catch (std::out_of_range& e) {
42946       {
42947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42948       };
42949     } catch (std::exception& e) {
42950       {
42951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42952       };
42953     } catch (...) {
42954       {
42955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42956       };
42957     }
42958   }
42959   jresult = (int)result;
42960   return jresult;
42961 }
42962
42963
42964 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42965   char * jresult ;
42966   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42967   std::string result;
42968
42969   arg1 = (Dali::ResourceImage *)jarg1;
42970   {
42971     try {
42972       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
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 = SWIG_csharp_string_callback((&result)->c_str());
42988   return jresult;
42989 }
42990
42991
42992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42993   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42994
42995   arg1 = (Dali::ResourceImage *)jarg1;
42996   {
42997     try {
42998       (arg1)->Reload();
42999     } catch (std::out_of_range& e) {
43000       {
43001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43002       };
43003     } catch (std::exception& e) {
43004       {
43005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43006       };
43007     } catch (...) {
43008       {
43009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43010       };
43011     }
43012   }
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43017   void * jresult ;
43018   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43019   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43020
43021   arg1 = (Dali::ResourceImage *)jarg1;
43022   {
43023     try {
43024       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43025     } catch (std::out_of_range& e) {
43026       {
43027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43028       };
43029     } catch (std::exception& e) {
43030       {
43031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (...) {
43034       {
43035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43036       };
43037     }
43038   }
43039   jresult = (void *)result;
43040   return jresult;
43041 }
43042
43043
43044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43045   void * jresult ;
43046   Dali::FrameBufferImage *result = 0 ;
43047
43048   {
43049     try {
43050       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43051     } catch (std::out_of_range& e) {
43052       {
43053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43054       };
43055     } catch (std::exception& e) {
43056       {
43057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43058       };
43059     } catch (...) {
43060       {
43061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43062       };
43063     }
43064   }
43065   jresult = (void *)result;
43066   return jresult;
43067 }
43068
43069
43070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43071   void * jresult ;
43072   unsigned int arg1 ;
43073   unsigned int arg2 ;
43074   Dali::Pixel::Format arg3 ;
43075   Dali::RenderBuffer::Format arg4 ;
43076   Dali::FrameBufferImage result;
43077
43078   arg1 = (unsigned int)jarg1;
43079   arg2 = (unsigned int)jarg2;
43080   arg3 = (Dali::Pixel::Format)jarg3;
43081   arg4 = (Dali::RenderBuffer::Format)jarg4;
43082   {
43083     try {
43084       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43085     } catch (std::out_of_range& e) {
43086       {
43087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43088       };
43089     } catch (std::exception& e) {
43090       {
43091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43092       };
43093     } catch (...) {
43094       {
43095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43096       };
43097     }
43098   }
43099   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43100   return jresult;
43101 }
43102
43103
43104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43105   void * jresult ;
43106   unsigned int arg1 ;
43107   unsigned int arg2 ;
43108   Dali::Pixel::Format arg3 ;
43109   Dali::FrameBufferImage result;
43110
43111   arg1 = (unsigned int)jarg1;
43112   arg2 = (unsigned int)jarg2;
43113   arg3 = (Dali::Pixel::Format)jarg3;
43114   {
43115     try {
43116       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43117     } catch (std::out_of_range& e) {
43118       {
43119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43120       };
43121     } catch (std::exception& e) {
43122       {
43123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43124       };
43125     } catch (...) {
43126       {
43127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43128       };
43129     }
43130   }
43131   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43132   return jresult;
43133 }
43134
43135
43136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43137   void * jresult ;
43138   unsigned int arg1 ;
43139   unsigned int arg2 ;
43140   Dali::FrameBufferImage result;
43141
43142   arg1 = (unsigned int)jarg1;
43143   arg2 = (unsigned int)jarg2;
43144   {
43145     try {
43146       result = Dali::FrameBufferImage::New(arg1,arg2);
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (...) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43158       };
43159     }
43160   }
43161   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43162   return jresult;
43163 }
43164
43165
43166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43167   void * jresult ;
43168   unsigned int arg1 ;
43169   Dali::FrameBufferImage result;
43170
43171   arg1 = (unsigned int)jarg1;
43172   {
43173     try {
43174       result = Dali::FrameBufferImage::New(arg1);
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43182       };
43183     } catch (...) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43186       };
43187     }
43188   }
43189   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43190   return jresult;
43191 }
43192
43193
43194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43195   void * jresult ;
43196   Dali::FrameBufferImage result;
43197
43198   {
43199     try {
43200       result = Dali::FrameBufferImage::New();
43201     } catch (std::out_of_range& e) {
43202       {
43203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (std::exception& e) {
43206       {
43207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (...) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43212       };
43213     }
43214   }
43215   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43216   return jresult;
43217 }
43218
43219
43220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43221   void * jresult ;
43222   Dali::NativeImageInterface *arg1 = 0 ;
43223   Dali::FrameBufferImage result;
43224
43225   arg1 = (Dali::NativeImageInterface *)jarg1;
43226   if (!arg1) {
43227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43228     return 0;
43229   }
43230   {
43231     try {
43232       result = Dali::FrameBufferImage::New(*arg1);
43233     } catch (std::out_of_range& e) {
43234       {
43235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43236       };
43237     } catch (std::exception& e) {
43238       {
43239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43240       };
43241     } catch (...) {
43242       {
43243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43244       };
43245     }
43246   }
43247   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43248   return jresult;
43249 }
43250
43251
43252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43253   void * jresult ;
43254   Dali::BaseHandle arg1 ;
43255   Dali::BaseHandle *argp1 ;
43256   Dali::FrameBufferImage result;
43257
43258   argp1 = (Dali::BaseHandle *)jarg1;
43259   if (!argp1) {
43260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43261     return 0;
43262   }
43263   arg1 = *argp1;
43264   {
43265     try {
43266       result = Dali::FrameBufferImage::DownCast(arg1);
43267     } catch (std::out_of_range& e) {
43268       {
43269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43270       };
43271     } catch (std::exception& e) {
43272       {
43273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43274       };
43275     } catch (...) {
43276       {
43277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43278       };
43279     }
43280   }
43281   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43282   return jresult;
43283 }
43284
43285
43286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43287   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43288
43289   arg1 = (Dali::FrameBufferImage *)jarg1;
43290   {
43291     try {
43292       delete arg1;
43293     } catch (std::out_of_range& e) {
43294       {
43295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43296       };
43297     } catch (std::exception& e) {
43298       {
43299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43300       };
43301     } catch (...) {
43302       {
43303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43304       };
43305     }
43306   }
43307 }
43308
43309
43310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43311   void * jresult ;
43312   Dali::FrameBufferImage *arg1 = 0 ;
43313   Dali::FrameBufferImage *result = 0 ;
43314
43315   arg1 = (Dali::FrameBufferImage *)jarg1;
43316   if (!arg1) {
43317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43318     return 0;
43319   }
43320   {
43321     try {
43322       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43323     } catch (std::out_of_range& e) {
43324       {
43325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43326       };
43327     } catch (std::exception& e) {
43328       {
43329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43330       };
43331     } catch (...) {
43332       {
43333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43334       };
43335     }
43336   }
43337   jresult = (void *)result;
43338   return jresult;
43339 }
43340
43341
43342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43343   void * jresult ;
43344   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43345   Dali::FrameBufferImage *arg2 = 0 ;
43346   Dali::FrameBufferImage *result = 0 ;
43347
43348   arg1 = (Dali::FrameBufferImage *)jarg1;
43349   arg2 = (Dali::FrameBufferImage *)jarg2;
43350   if (!arg2) {
43351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43352     return 0;
43353   }
43354   {
43355     try {
43356       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43357     } catch (std::out_of_range& e) {
43358       {
43359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43360       };
43361     } catch (std::exception& e) {
43362       {
43363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43364       };
43365     } catch (...) {
43366       {
43367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43368       };
43369     }
43370   }
43371   jresult = (void *)result;
43372   return jresult;
43373 }
43374
43375
43376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43377   void * jresult ;
43378   Dali::NinePatchImage *result = 0 ;
43379
43380   {
43381     try {
43382       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43383     } catch (std::out_of_range& e) {
43384       {
43385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (std::exception& e) {
43388       {
43389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43394       };
43395     }
43396   }
43397   jresult = (void *)result;
43398   return jresult;
43399 }
43400
43401
43402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43403   void * jresult ;
43404   std::string *arg1 = 0 ;
43405   Dali::NinePatchImage result;
43406
43407   if (!jarg1) {
43408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43409     return 0;
43410   }
43411   std::string arg1_str(jarg1);
43412   arg1 = &arg1_str;
43413   {
43414     try {
43415       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43416     } catch (std::out_of_range& e) {
43417       {
43418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (std::exception& e) {
43421       {
43422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43431
43432   //argout typemap for const std::string&
43433
43434   return jresult;
43435 }
43436
43437
43438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43439   void * jresult ;
43440   Dali::BaseHandle arg1 ;
43441   Dali::BaseHandle *argp1 ;
43442   Dali::NinePatchImage result;
43443
43444   argp1 = (Dali::BaseHandle *)jarg1;
43445   if (!argp1) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43447     return 0;
43448   }
43449   arg1 = *argp1;
43450   {
43451     try {
43452       result = Dali::NinePatchImage::DownCast(arg1);
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 = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43473   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43474
43475   arg1 = (Dali::NinePatchImage *)jarg1;
43476   {
43477     try {
43478       delete arg1;
43479     } catch (std::out_of_range& e) {
43480       {
43481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43482       };
43483     } catch (std::exception& e) {
43484       {
43485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43486       };
43487     } catch (...) {
43488       {
43489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43490       };
43491     }
43492   }
43493 }
43494
43495
43496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43497   void * jresult ;
43498   Dali::NinePatchImage *arg1 = 0 ;
43499   Dali::NinePatchImage *result = 0 ;
43500
43501   arg1 = (Dali::NinePatchImage *)jarg1;
43502   if (!arg1) {
43503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43504     return 0;
43505   }
43506   {
43507     try {
43508       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
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 = (void *)result;
43524   return jresult;
43525 }
43526
43527
43528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43529   void * jresult ;
43530   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43531   Dali::NinePatchImage *arg2 = 0 ;
43532   Dali::NinePatchImage *result = 0 ;
43533
43534   arg1 = (Dali::NinePatchImage *)jarg1;
43535   arg2 = (Dali::NinePatchImage *)jarg2;
43536   if (!arg2) {
43537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43538     return 0;
43539   }
43540   {
43541     try {
43542       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43543     } catch (std::out_of_range& e) {
43544       {
43545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43546       };
43547     } catch (std::exception& e) {
43548       {
43549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43550       };
43551     } catch (...) {
43552       {
43553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43554       };
43555     }
43556   }
43557   jresult = (void *)result;
43558   return jresult;
43559 }
43560
43561
43562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43563   void * jresult ;
43564   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43565   Dali::Vector4 result;
43566
43567   arg1 = (Dali::NinePatchImage *)jarg1;
43568   {
43569     try {
43570       result = (arg1)->GetStretchBorders();
43571     } catch (std::out_of_range& e) {
43572       {
43573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43574       };
43575     } catch (std::exception& e) {
43576       {
43577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43578       };
43579     } catch (...) {
43580       {
43581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43582       };
43583     }
43584   }
43585   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43586   return jresult;
43587 }
43588
43589
43590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43591   void * jresult ;
43592   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43593   Dali::NinePatchImage::StretchRanges *result = 0 ;
43594
43595   arg1 = (Dali::NinePatchImage *)jarg1;
43596   {
43597     try {
43598       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43599     } catch (std::out_of_range& e) {
43600       {
43601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43602       };
43603     } catch (std::exception& e) {
43604       {
43605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43606       };
43607     } catch (...) {
43608       {
43609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43610       };
43611     }
43612   }
43613   jresult = (void *)result;
43614   return jresult;
43615 }
43616
43617
43618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43619   void * jresult ;
43620   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43621   Dali::NinePatchImage::StretchRanges *result = 0 ;
43622
43623   arg1 = (Dali::NinePatchImage *)jarg1;
43624   {
43625     try {
43626       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43627     } catch (std::out_of_range& e) {
43628       {
43629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43630       };
43631     } catch (std::exception& e) {
43632       {
43633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43634       };
43635     } catch (...) {
43636       {
43637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43638       };
43639     }
43640   }
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43647   void * jresult ;
43648   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43649   Dali::Rect< int > result;
43650
43651   arg1 = (Dali::NinePatchImage *)jarg1;
43652   {
43653     try {
43654       result = (arg1)->GetChildRectangle();
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (...) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43666       };
43667     }
43668   }
43669   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43675   void * jresult ;
43676   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43677   Dali::BufferImage result;
43678
43679   arg1 = (Dali::NinePatchImage *)jarg1;
43680   {
43681     try {
43682       result = (arg1)->CreateCroppedBufferImage();
43683     } catch (std::out_of_range& e) {
43684       {
43685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (std::exception& e) {
43688       {
43689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43698   return jresult;
43699 }
43700
43701
43702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43703   unsigned int jresult ;
43704   std::string *arg1 = 0 ;
43705   bool result;
43706
43707   if (!jarg1) {
43708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43709     return 0;
43710   }
43711   std::string arg1_str(jarg1);
43712   arg1 = &arg1_str;
43713   {
43714     try {
43715       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43716     } catch (std::out_of_range& e) {
43717       {
43718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43719       };
43720     } catch (std::exception& e) {
43721       {
43722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (...) {
43725       {
43726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43727       };
43728     }
43729   }
43730   jresult = result;
43731
43732   //argout typemap for const std::string&
43733
43734   return jresult;
43735 }
43736
43737
43738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43739   int jresult ;
43740   int result;
43741
43742   result = (int)Dali::CameraActor::Property::TYPE;
43743   jresult = (int)result;
43744   return jresult;
43745 }
43746
43747
43748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43749   int jresult ;
43750   int result;
43751
43752   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43753   jresult = (int)result;
43754   return jresult;
43755 }
43756
43757
43758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43759   int jresult ;
43760   int result;
43761
43762   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43763   jresult = (int)result;
43764   return jresult;
43765 }
43766
43767
43768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43769   int jresult ;
43770   int result;
43771
43772   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43773   jresult = (int)result;
43774   return jresult;
43775 }
43776
43777
43778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43779   int jresult ;
43780   int result;
43781
43782   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43783   jresult = (int)result;
43784   return jresult;
43785 }
43786
43787
43788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43789   int jresult ;
43790   int result;
43791
43792   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43793   jresult = (int)result;
43794   return jresult;
43795 }
43796
43797
43798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43799   int jresult ;
43800   int result;
43801
43802   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43803   jresult = (int)result;
43804   return jresult;
43805 }
43806
43807
43808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43809   int jresult ;
43810   int result;
43811
43812   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43813   jresult = (int)result;
43814   return jresult;
43815 }
43816
43817
43818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43819   int jresult ;
43820   int result;
43821
43822   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43823   jresult = (int)result;
43824   return jresult;
43825 }
43826
43827
43828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43829   int jresult ;
43830   int result;
43831
43832   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43833   jresult = (int)result;
43834   return jresult;
43835 }
43836
43837
43838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43839   int jresult ;
43840   int result;
43841
43842   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43843   jresult = (int)result;
43844   return jresult;
43845 }
43846
43847
43848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43849   int jresult ;
43850   int result;
43851
43852   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43853   jresult = (int)result;
43854   return jresult;
43855 }
43856
43857
43858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43859   int jresult ;
43860   int result;
43861
43862   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43863   jresult = (int)result;
43864   return jresult;
43865 }
43866
43867
43868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43869   int jresult ;
43870   int result;
43871
43872   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43873   jresult = (int)result;
43874   return jresult;
43875 }
43876
43877
43878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43879   void * jresult ;
43880   Dali::CameraActor::Property *result = 0 ;
43881
43882   {
43883     try {
43884       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43885     } catch (std::out_of_range& e) {
43886       {
43887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43888       };
43889     } catch (std::exception& e) {
43890       {
43891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43892       };
43893     } catch (...) {
43894       {
43895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43896       };
43897     }
43898   }
43899   jresult = (void *)result;
43900   return jresult;
43901 }
43902
43903
43904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43905   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43906
43907   arg1 = (Dali::CameraActor::Property *)jarg1;
43908   {
43909     try {
43910       delete arg1;
43911     } catch (std::out_of_range& e) {
43912       {
43913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43914       };
43915     } catch (std::exception& e) {
43916       {
43917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43918       };
43919     } catch (...) {
43920       {
43921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43922       };
43923     }
43924   }
43925 }
43926
43927
43928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43929   void * jresult ;
43930   Dali::CameraActor *result = 0 ;
43931
43932   {
43933     try {
43934       result = (Dali::CameraActor *)new Dali::CameraActor();
43935     } catch (std::out_of_range& e) {
43936       {
43937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43938       };
43939     } catch (std::exception& e) {
43940       {
43941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (...) {
43944       {
43945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43946       };
43947     }
43948   }
43949   jresult = (void *)result;
43950   return jresult;
43951 }
43952
43953
43954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43955   void * jresult ;
43956   Dali::CameraActor result;
43957
43958   {
43959     try {
43960       result = Dali::CameraActor::New();
43961     } catch (std::out_of_range& e) {
43962       {
43963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43964       };
43965     } catch (std::exception& e) {
43966       {
43967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43968       };
43969     } catch (...) {
43970       {
43971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43972       };
43973     }
43974   }
43975   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43976   return jresult;
43977 }
43978
43979
43980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43981   void * jresult ;
43982   Dali::Size *arg1 = 0 ;
43983   Dali::CameraActor result;
43984
43985   arg1 = (Dali::Size *)jarg1;
43986   if (!arg1) {
43987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43988     return 0;
43989   }
43990   {
43991     try {
43992       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43993     } catch (std::out_of_range& e) {
43994       {
43995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43996       };
43997     } catch (std::exception& e) {
43998       {
43999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44000       };
44001     } catch (...) {
44002       {
44003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44004       };
44005     }
44006   }
44007   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44008   return jresult;
44009 }
44010
44011
44012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44013   void * jresult ;
44014   Dali::BaseHandle arg1 ;
44015   Dali::BaseHandle *argp1 ;
44016   Dali::CameraActor result;
44017
44018   argp1 = (Dali::BaseHandle *)jarg1;
44019   if (!argp1) {
44020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44021     return 0;
44022   }
44023   arg1 = *argp1;
44024   {
44025     try {
44026       result = Dali::CameraActor::DownCast(arg1);
44027     } catch (std::out_of_range& e) {
44028       {
44029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44030       };
44031     } catch (std::exception& e) {
44032       {
44033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44034       };
44035     } catch (...) {
44036       {
44037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44038       };
44039     }
44040   }
44041   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44042   return jresult;
44043 }
44044
44045
44046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44047   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44048
44049   arg1 = (Dali::CameraActor *)jarg1;
44050   {
44051     try {
44052       delete arg1;
44053     } catch (std::out_of_range& e) {
44054       {
44055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44056       };
44057     } catch (std::exception& e) {
44058       {
44059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44060       };
44061     } catch (...) {
44062       {
44063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44064       };
44065     }
44066   }
44067 }
44068
44069
44070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44071   void * jresult ;
44072   Dali::CameraActor *arg1 = 0 ;
44073   Dali::CameraActor *result = 0 ;
44074
44075   arg1 = (Dali::CameraActor *)jarg1;
44076   if (!arg1) {
44077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44078     return 0;
44079   }
44080   {
44081     try {
44082       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44083     } catch (std::out_of_range& e) {
44084       {
44085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44086       };
44087     } catch (std::exception& e) {
44088       {
44089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44090       };
44091     } catch (...) {
44092       {
44093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44094       };
44095     }
44096   }
44097   jresult = (void *)result;
44098   return jresult;
44099 }
44100
44101
44102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44103   void * jresult ;
44104   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44105   Dali::CameraActor *arg2 = 0 ;
44106   Dali::CameraActor *result = 0 ;
44107
44108   arg1 = (Dali::CameraActor *)jarg1;
44109   arg2 = (Dali::CameraActor *)jarg2;
44110   if (!arg2) {
44111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44112     return 0;
44113   }
44114   {
44115     try {
44116       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44117     } catch (std::out_of_range& e) {
44118       {
44119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44120       };
44121     } catch (std::exception& e) {
44122       {
44123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44124       };
44125     } catch (...) {
44126       {
44127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44128       };
44129     }
44130   }
44131   jresult = (void *)result;
44132   return jresult;
44133 }
44134
44135
44136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44137   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44138   Dali::Camera::Type arg2 ;
44139
44140   arg1 = (Dali::CameraActor *)jarg1;
44141   arg2 = (Dali::Camera::Type)jarg2;
44142   {
44143     try {
44144       (arg1)->SetType(arg2);
44145     } catch (std::out_of_range& e) {
44146       {
44147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44148       };
44149     } catch (std::exception& e) {
44150       {
44151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44152       };
44153     } catch (...) {
44154       {
44155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44156       };
44157     }
44158   }
44159 }
44160
44161
44162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44163   int jresult ;
44164   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44165   Dali::Camera::Type result;
44166
44167   arg1 = (Dali::CameraActor *)jarg1;
44168   {
44169     try {
44170       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44171     } catch (std::out_of_range& e) {
44172       {
44173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44174       };
44175     } catch (std::exception& e) {
44176       {
44177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44178       };
44179     } catch (...) {
44180       {
44181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44182       };
44183     }
44184   }
44185   jresult = (int)result;
44186   return jresult;
44187 }
44188
44189
44190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44191   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44192   Dali::Camera::ProjectionMode arg2 ;
44193
44194   arg1 = (Dali::CameraActor *)jarg1;
44195   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44196   {
44197     try {
44198       (arg1)->SetProjectionMode(arg2);
44199     } catch (std::out_of_range& e) {
44200       {
44201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44202       };
44203     } catch (std::exception& e) {
44204       {
44205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44206       };
44207     } catch (...) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44210       };
44211     }
44212   }
44213 }
44214
44215
44216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44217   int jresult ;
44218   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44219   Dali::Camera::ProjectionMode result;
44220
44221   arg1 = (Dali::CameraActor *)jarg1;
44222   {
44223     try {
44224       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44225     } catch (std::out_of_range& e) {
44226       {
44227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44228       };
44229     } catch (std::exception& e) {
44230       {
44231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44232       };
44233     } catch (...) {
44234       {
44235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44236       };
44237     }
44238   }
44239   jresult = (int)result;
44240   return jresult;
44241 }
44242
44243
44244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44245   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44246   float arg2 ;
44247
44248   arg1 = (Dali::CameraActor *)jarg1;
44249   arg2 = (float)jarg2;
44250   {
44251     try {
44252       (arg1)->SetFieldOfView(arg2);
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (...) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44264       };
44265     }
44266   }
44267 }
44268
44269
44270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44271   float jresult ;
44272   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44273   float result;
44274
44275   arg1 = (Dali::CameraActor *)jarg1;
44276   {
44277     try {
44278       result = (float)(arg1)->GetFieldOfView();
44279     } catch (std::out_of_range& e) {
44280       {
44281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44282       };
44283     } catch (std::exception& e) {
44284       {
44285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44286       };
44287     } catch (...) {
44288       {
44289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44290       };
44291     }
44292   }
44293   jresult = result;
44294   return jresult;
44295 }
44296
44297
44298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44299   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44300   float arg2 ;
44301
44302   arg1 = (Dali::CameraActor *)jarg1;
44303   arg2 = (float)jarg2;
44304   {
44305     try {
44306       (arg1)->SetAspectRatio(arg2);
44307     } catch (std::out_of_range& e) {
44308       {
44309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44310       };
44311     } catch (std::exception& e) {
44312       {
44313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44314       };
44315     } catch (...) {
44316       {
44317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44318       };
44319     }
44320   }
44321 }
44322
44323
44324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44325   float jresult ;
44326   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44327   float result;
44328
44329   arg1 = (Dali::CameraActor *)jarg1;
44330   {
44331     try {
44332       result = (float)(arg1)->GetAspectRatio();
44333     } catch (std::out_of_range& e) {
44334       {
44335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44336       };
44337     } catch (std::exception& e) {
44338       {
44339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44340       };
44341     } catch (...) {
44342       {
44343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44344       };
44345     }
44346   }
44347   jresult = result;
44348   return jresult;
44349 }
44350
44351
44352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44353   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44354   float arg2 ;
44355
44356   arg1 = (Dali::CameraActor *)jarg1;
44357   arg2 = (float)jarg2;
44358   {
44359     try {
44360       (arg1)->SetNearClippingPlane(arg2);
44361     } catch (std::out_of_range& e) {
44362       {
44363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44364       };
44365     } catch (std::exception& e) {
44366       {
44367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44368       };
44369     } catch (...) {
44370       {
44371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44372       };
44373     }
44374   }
44375 }
44376
44377
44378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44379   float jresult ;
44380   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44381   float result;
44382
44383   arg1 = (Dali::CameraActor *)jarg1;
44384   {
44385     try {
44386       result = (float)(arg1)->GetNearClippingPlane();
44387     } catch (std::out_of_range& e) {
44388       {
44389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44390       };
44391     } catch (std::exception& e) {
44392       {
44393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44398       };
44399     }
44400   }
44401   jresult = result;
44402   return jresult;
44403 }
44404
44405
44406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44407   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44408   float arg2 ;
44409
44410   arg1 = (Dali::CameraActor *)jarg1;
44411   arg2 = (float)jarg2;
44412   {
44413     try {
44414       (arg1)->SetFarClippingPlane(arg2);
44415     } catch (std::out_of_range& e) {
44416       {
44417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44418       };
44419     } catch (std::exception& e) {
44420       {
44421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44422       };
44423     } catch (...) {
44424       {
44425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44426       };
44427     }
44428   }
44429 }
44430
44431
44432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44433   float jresult ;
44434   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44435   float result;
44436
44437   arg1 = (Dali::CameraActor *)jarg1;
44438   {
44439     try {
44440       result = (float)(arg1)->GetFarClippingPlane();
44441     } catch (std::out_of_range& e) {
44442       {
44443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44444       };
44445     } catch (std::exception& e) {
44446       {
44447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44448       };
44449     } catch (...) {
44450       {
44451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44452       };
44453     }
44454   }
44455   jresult = result;
44456   return jresult;
44457 }
44458
44459
44460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44461   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44462   Dali::Vector3 *arg2 = 0 ;
44463
44464   arg1 = (Dali::CameraActor *)jarg1;
44465   arg2 = (Dali::Vector3 *)jarg2;
44466   if (!arg2) {
44467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44468     return ;
44469   }
44470   {
44471     try {
44472       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44473     } catch (std::out_of_range& e) {
44474       {
44475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44476       };
44477     } catch (std::exception& e) {
44478       {
44479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (...) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44484       };
44485     }
44486   }
44487 }
44488
44489
44490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44491   void * jresult ;
44492   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44493   Dali::Vector3 result;
44494
44495   arg1 = (Dali::CameraActor *)jarg1;
44496   {
44497     try {
44498       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44499     } catch (std::out_of_range& e) {
44500       {
44501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44502       };
44503     } catch (std::exception& e) {
44504       {
44505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44506       };
44507     } catch (...) {
44508       {
44509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44510       };
44511     }
44512   }
44513   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44514   return jresult;
44515 }
44516
44517
44518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44519   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44520   bool arg2 ;
44521
44522   arg1 = (Dali::CameraActor *)jarg1;
44523   arg2 = jarg2 ? true : false;
44524   {
44525     try {
44526       (arg1)->SetInvertYAxis(arg2);
44527     } catch (std::out_of_range& e) {
44528       {
44529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44530       };
44531     } catch (std::exception& e) {
44532       {
44533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44534       };
44535     } catch (...) {
44536       {
44537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44538       };
44539     }
44540   }
44541 }
44542
44543
44544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44545   unsigned int jresult ;
44546   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44547   bool result;
44548
44549   arg1 = (Dali::CameraActor *)jarg1;
44550   {
44551     try {
44552       result = (bool)(arg1)->GetInvertYAxis();
44553     } catch (std::out_of_range& e) {
44554       {
44555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44556       };
44557     } catch (std::exception& e) {
44558       {
44559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44560       };
44561     } catch (...) {
44562       {
44563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44564       };
44565     }
44566   }
44567   jresult = result;
44568   return jresult;
44569 }
44570
44571
44572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44573   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44574   Dali::Size *arg2 = 0 ;
44575
44576   arg1 = (Dali::CameraActor *)jarg1;
44577   arg2 = (Dali::Size *)jarg2;
44578   if (!arg2) {
44579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44580     return ;
44581   }
44582   {
44583     try {
44584       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44585     } catch (std::out_of_range& e) {
44586       {
44587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44588       };
44589     } catch (std::exception& e) {
44590       {
44591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44592       };
44593     } catch (...) {
44594       {
44595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44596       };
44597     }
44598   }
44599 }
44600
44601
44602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44604   Dali::Size *arg2 = 0 ;
44605
44606   arg1 = (Dali::CameraActor *)jarg1;
44607   arg2 = (Dali::Size *)jarg2;
44608   if (!arg2) {
44609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44610     return ;
44611   }
44612   {
44613     try {
44614       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44615     } catch (std::out_of_range& e) {
44616       {
44617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44618       };
44619     } catch (std::exception& e) {
44620       {
44621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44622       };
44623     } catch (...) {
44624       {
44625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44626       };
44627     }
44628   }
44629 }
44630
44631
44632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44633   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44634   float arg2 ;
44635   float arg3 ;
44636   float arg4 ;
44637   float arg5 ;
44638   float arg6 ;
44639   float arg7 ;
44640
44641   arg1 = (Dali::CameraActor *)jarg1;
44642   arg2 = (float)jarg2;
44643   arg3 = (float)jarg3;
44644   arg4 = (float)jarg4;
44645   arg5 = (float)jarg5;
44646   arg6 = (float)jarg6;
44647   arg7 = (float)jarg7;
44648   {
44649     try {
44650       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
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_new_StringValuePair__SWIG_0() {
44669   void * jresult ;
44670   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44671
44672   {
44673     try {
44674       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44675     } catch (std::out_of_range& e) {
44676       {
44677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44678       };
44679     } catch (std::exception& e) {
44680       {
44681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44682       };
44683     } catch (...) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44686       };
44687     }
44688   }
44689   jresult = (void *)result;
44690   return jresult;
44691 }
44692
44693
44694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44695   void * jresult ;
44696   std::string arg1 ;
44697   Dali::Property::Value arg2 ;
44698   Dali::Property::Value *argp2 ;
44699   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44700
44701   if (!jarg1) {
44702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44703     return 0;
44704   }
44705   (&arg1)->assign(jarg1);
44706   argp2 = (Dali::Property::Value *)jarg2;
44707   if (!argp2) {
44708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44709     return 0;
44710   }
44711   arg2 = *argp2;
44712   {
44713     try {
44714       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44715     } catch (std::out_of_range& e) {
44716       {
44717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44718       };
44719     } catch (std::exception& e) {
44720       {
44721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44722       };
44723     } catch (...) {
44724       {
44725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44726       };
44727     }
44728   }
44729   jresult = (void *)result;
44730   return jresult;
44731 }
44732
44733
44734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44735   void * jresult ;
44736   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44737   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44738
44739   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44740   if (!arg1) {
44741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44742     return 0;
44743   }
44744   {
44745     try {
44746       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);
44747     } catch (std::out_of_range& e) {
44748       {
44749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44750       };
44751     } catch (std::exception& e) {
44752       {
44753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44754       };
44755     } catch (...) {
44756       {
44757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44758       };
44759     }
44760   }
44761   jresult = (void *)result;
44762   return jresult;
44763 }
44764
44765
44766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44767   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44768   std::string *arg2 = 0 ;
44769
44770   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44771   if (!jarg2) {
44772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44773     return ;
44774   }
44775   std::string arg2_str(jarg2);
44776   arg2 = &arg2_str;
44777   if (arg1) (arg1)->first = *arg2;
44778
44779   //argout typemap for const std::string&
44780
44781 }
44782
44783
44784 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44785   char * jresult ;
44786   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44787   std::string *result = 0 ;
44788
44789   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44790   result = (std::string *) & ((arg1)->first);
44791   jresult = SWIG_csharp_string_callback(result->c_str());
44792   return jresult;
44793 }
44794
44795
44796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44797   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44798   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44799
44800   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44801   arg2 = (Dali::Property::Value *)jarg2;
44802   if (arg1) (arg1)->second = *arg2;
44803 }
44804
44805
44806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44807   void * jresult ;
44808   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44809   Dali::Property::Value *result = 0 ;
44810
44811   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44812   result = (Dali::Property::Value *)& ((arg1)->second);
44813   jresult = (void *)result;
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44819   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44820
44821   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44822   {
44823     try {
44824       delete arg1;
44825     } catch (std::out_of_range& e) {
44826       {
44827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44828       };
44829     } catch (std::exception& e) {
44830       {
44831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44832       };
44833     } catch (...) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44836       };
44837     }
44838   }
44839 }
44840
44841
44842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44843   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44844
44845   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44846   {
44847     try {
44848       (arg1)->clear();
44849     } catch (std::out_of_range& e) {
44850       {
44851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44852       };
44853     } catch (std::exception& e) {
44854       {
44855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44856       };
44857     } catch (...) {
44858       {
44859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44860       };
44861     }
44862   }
44863 }
44864
44865
44866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44867   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44868   Dali::TouchPoint *arg2 = 0 ;
44869
44870   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44871   arg2 = (Dali::TouchPoint *)jarg2;
44872   if (!arg2) {
44873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44874     return ;
44875   }
44876   {
44877     try {
44878       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44879     } catch (std::out_of_range& e) {
44880       {
44881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44882       };
44883     } catch (std::exception& e) {
44884       {
44885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44886       };
44887     } catch (...) {
44888       {
44889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44890       };
44891     }
44892   }
44893 }
44894
44895
44896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44897   unsigned long jresult ;
44898   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44899   std::vector< Dali::TouchPoint >::size_type result;
44900
44901   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44902   {
44903     try {
44904       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44905     } catch (std::out_of_range& e) {
44906       {
44907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44908       };
44909     } catch (std::exception& e) {
44910       {
44911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44912       };
44913     } catch (...) {
44914       {
44915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44916       };
44917     }
44918   }
44919   jresult = (unsigned long)result;
44920   return jresult;
44921 }
44922
44923
44924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44925   unsigned long jresult ;
44926   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44927   std::vector< Dali::TouchPoint >::size_type result;
44928
44929   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44930   {
44931     try {
44932       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44933     } catch (std::out_of_range& e) {
44934       {
44935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44936       };
44937     } catch (std::exception& e) {
44938       {
44939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44940       };
44941     } catch (...) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44944       };
44945     }
44946   }
44947   jresult = (unsigned long)result;
44948   return jresult;
44949 }
44950
44951
44952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44953   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44954   std::vector< Dali::TouchPoint >::size_type arg2 ;
44955
44956   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44957   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44958   {
44959     try {
44960       (arg1)->reserve(arg2);
44961     } catch (std::out_of_range& e) {
44962       {
44963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44964       };
44965     } catch (std::exception& e) {
44966       {
44967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44968       };
44969     } catch (...) {
44970       {
44971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44972       };
44973     }
44974   }
44975 }
44976
44977
44978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44979   void * jresult ;
44980   std::vector< Dali::TouchPoint > *result = 0 ;
44981
44982   {
44983     try {
44984       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44985     } catch (std::out_of_range& e) {
44986       {
44987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44988       };
44989     } catch (std::exception& e) {
44990       {
44991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44992       };
44993     } catch (...) {
44994       {
44995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44996       };
44997     }
44998   }
44999   jresult = (void *)result;
45000   return jresult;
45001 }
45002
45003
45004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45005   void * jresult ;
45006   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45007   std::vector< Dali::TouchPoint > *result = 0 ;
45008
45009   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45010   if (!arg1) {
45011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45012     return 0;
45013   }
45014   {
45015     try {
45016       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45017     } catch (std::out_of_range& e) {
45018       {
45019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45020       };
45021     } catch (std::exception& e) {
45022       {
45023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45024       };
45025     } catch (...) {
45026       {
45027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45028       };
45029     }
45030   }
45031   jresult = (void *)result;
45032   return jresult;
45033 }
45034
45035
45036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45037   void * jresult ;
45038   int arg1 ;
45039   std::vector< Dali::TouchPoint > *result = 0 ;
45040
45041   arg1 = (int)jarg1;
45042   {
45043     try {
45044       try {
45045         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45046       }
45047       catch(std::out_of_range &_e) {
45048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45049         return 0;
45050       }
45051
45052     } catch (std::out_of_range& e) {
45053       {
45054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45055       };
45056     } catch (std::exception& e) {
45057       {
45058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45059       };
45060     } catch (...) {
45061       {
45062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45063       };
45064     }
45065   }
45066   jresult = (void *)result;
45067   return jresult;
45068 }
45069
45070
45071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45072   void * jresult ;
45073   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45074   int arg2 ;
45075   SwigValueWrapper< Dali::TouchPoint > result;
45076
45077   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45078   arg2 = (int)jarg2;
45079   {
45080     try {
45081       try {
45082         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45083       }
45084       catch(std::out_of_range &_e) {
45085         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45086         return 0;
45087       }
45088
45089     } catch (std::out_of_range& e) {
45090       {
45091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45092       };
45093     } catch (std::exception& e) {
45094       {
45095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45096       };
45097     } catch (...) {
45098       {
45099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45100       };
45101     }
45102   }
45103   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45104   return jresult;
45105 }
45106
45107
45108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45109   void * jresult ;
45110   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45111   int arg2 ;
45112   Dali::TouchPoint *result = 0 ;
45113
45114   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45115   arg2 = (int)jarg2;
45116   {
45117     try {
45118       try {
45119         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45120       }
45121       catch(std::out_of_range &_e) {
45122         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45123         return 0;
45124       }
45125
45126     } catch (std::out_of_range& e) {
45127       {
45128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45129       };
45130     } catch (std::exception& e) {
45131       {
45132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45133       };
45134     } catch (...) {
45135       {
45136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45137       };
45138     }
45139   }
45140   jresult = (void *)result;
45141   return jresult;
45142 }
45143
45144
45145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45146   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45147   int arg2 ;
45148   Dali::TouchPoint *arg3 = 0 ;
45149
45150   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45151   arg2 = (int)jarg2;
45152   arg3 = (Dali::TouchPoint *)jarg3;
45153   if (!arg3) {
45154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45155     return ;
45156   }
45157   {
45158     try {
45159       try {
45160         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45161       }
45162       catch(std::out_of_range &_e) {
45163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45164         return ;
45165       }
45166
45167     } catch (std::out_of_range& e) {
45168       {
45169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45170       };
45171     } catch (std::exception& e) {
45172       {
45173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45174       };
45175     } catch (...) {
45176       {
45177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45178       };
45179     }
45180   }
45181 }
45182
45183
45184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45185   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45186   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45187
45188   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45189   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45190   if (!arg2) {
45191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45192     return ;
45193   }
45194   {
45195     try {
45196       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45197     } catch (std::out_of_range& e) {
45198       {
45199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45200       };
45201     } catch (std::exception& e) {
45202       {
45203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45204       };
45205     } catch (...) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45208       };
45209     }
45210   }
45211 }
45212
45213
45214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45215   void * jresult ;
45216   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45217   int arg2 ;
45218   int arg3 ;
45219   std::vector< Dali::TouchPoint > *result = 0 ;
45220
45221   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45222   arg2 = (int)jarg2;
45223   arg3 = (int)jarg3;
45224   {
45225     try {
45226       try {
45227         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45228       }
45229       catch(std::out_of_range &_e) {
45230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45231         return 0;
45232       }
45233       catch(std::invalid_argument &_e) {
45234         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45235         return 0;
45236       }
45237
45238     } catch (std::out_of_range& e) {
45239       {
45240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (std::exception& e) {
45243       {
45244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (...) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45249       };
45250     }
45251   }
45252   jresult = (void *)result;
45253   return jresult;
45254 }
45255
45256
45257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45258   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45259   int arg2 ;
45260   Dali::TouchPoint *arg3 = 0 ;
45261
45262   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45263   arg2 = (int)jarg2;
45264   arg3 = (Dali::TouchPoint *)jarg3;
45265   if (!arg3) {
45266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45267     return ;
45268   }
45269   {
45270     try {
45271       try {
45272         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45273       }
45274       catch(std::out_of_range &_e) {
45275         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45276         return ;
45277       }
45278
45279     } catch (std::out_of_range& e) {
45280       {
45281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45282       };
45283     } catch (std::exception& e) {
45284       {
45285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45286       };
45287     } catch (...) {
45288       {
45289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45290       };
45291     }
45292   }
45293 }
45294
45295
45296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45297   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45298   int arg2 ;
45299   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45300
45301   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45302   arg2 = (int)jarg2;
45303   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45304   if (!arg3) {
45305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45306     return ;
45307   }
45308   {
45309     try {
45310       try {
45311         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45312       }
45313       catch(std::out_of_range &_e) {
45314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45315         return ;
45316       }
45317
45318     } catch (std::out_of_range& e) {
45319       {
45320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45321       };
45322     } catch (std::exception& e) {
45323       {
45324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45325       };
45326     } catch (...) {
45327       {
45328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45329       };
45330     }
45331   }
45332 }
45333
45334
45335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45336   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45337   int arg2 ;
45338
45339   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45340   arg2 = (int)jarg2;
45341   {
45342     try {
45343       try {
45344         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45345       }
45346       catch(std::out_of_range &_e) {
45347         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45348         return ;
45349       }
45350
45351     } catch (std::out_of_range& e) {
45352       {
45353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45354       };
45355     } catch (std::exception& e) {
45356       {
45357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45358       };
45359     } catch (...) {
45360       {
45361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45362       };
45363     }
45364   }
45365 }
45366
45367
45368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45369   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45370   int arg2 ;
45371   int arg3 ;
45372
45373   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45374   arg2 = (int)jarg2;
45375   arg3 = (int)jarg3;
45376   {
45377     try {
45378       try {
45379         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45380       }
45381       catch(std::out_of_range &_e) {
45382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45383         return ;
45384       }
45385       catch(std::invalid_argument &_e) {
45386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45387         return ;
45388       }
45389
45390     } catch (std::out_of_range& e) {
45391       {
45392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45393       };
45394     } catch (std::exception& e) {
45395       {
45396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45397       };
45398     } catch (...) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45401       };
45402     }
45403   }
45404 }
45405
45406
45407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45408   void * jresult ;
45409   Dali::TouchPoint *arg1 = 0 ;
45410   int arg2 ;
45411   std::vector< Dali::TouchPoint > *result = 0 ;
45412
45413   arg1 = (Dali::TouchPoint *)jarg1;
45414   if (!arg1) {
45415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45416     return 0;
45417   }
45418   arg2 = (int)jarg2;
45419   {
45420     try {
45421       try {
45422         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45423       }
45424       catch(std::out_of_range &_e) {
45425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45426         return 0;
45427       }
45428
45429     } catch (std::out_of_range& e) {
45430       {
45431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45432       };
45433     } catch (std::exception& e) {
45434       {
45435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (...) {
45438       {
45439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45440       };
45441     }
45442   }
45443   jresult = (void *)result;
45444   return jresult;
45445 }
45446
45447
45448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45449   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45450
45451   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45452   {
45453     try {
45454       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45455     } catch (std::out_of_range& e) {
45456       {
45457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45458       };
45459     } catch (std::exception& e) {
45460       {
45461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45462       };
45463     } catch (...) {
45464       {
45465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45466       };
45467     }
45468   }
45469 }
45470
45471
45472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45473   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45474   int arg2 ;
45475   int arg3 ;
45476
45477   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45478   arg2 = (int)jarg2;
45479   arg3 = (int)jarg3;
45480   {
45481     try {
45482       try {
45483         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45484       }
45485       catch(std::out_of_range &_e) {
45486         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45487         return ;
45488       }
45489       catch(std::invalid_argument &_e) {
45490         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45491         return ;
45492       }
45493
45494     } catch (std::out_of_range& e) {
45495       {
45496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45497       };
45498     } catch (std::exception& e) {
45499       {
45500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45501       };
45502     } catch (...) {
45503       {
45504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45505       };
45506     }
45507   }
45508 }
45509
45510
45511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45512   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45513   int arg2 ;
45514   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45515
45516   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45517   arg2 = (int)jarg2;
45518   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45519   if (!arg3) {
45520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45521     return ;
45522   }
45523   {
45524     try {
45525       try {
45526         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45527       }
45528       catch(std::out_of_range &_e) {
45529         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45530         return ;
45531       }
45532
45533     } catch (std::out_of_range& e) {
45534       {
45535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45536       };
45537     } catch (std::exception& e) {
45538       {
45539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45540       };
45541     } catch (...) {
45542       {
45543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45544       };
45545     }
45546   }
45547 }
45548
45549
45550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45551   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45552
45553   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45554   {
45555     try {
45556       delete arg1;
45557     } catch (std::out_of_range& e) {
45558       {
45559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45560       };
45561     } catch (std::exception& e) {
45562       {
45563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45564       };
45565     } catch (...) {
45566       {
45567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45568       };
45569     }
45570   }
45571 }
45572
45573
45574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45575   void * jresult ;
45576   Dali::Rect< int > *result = 0 ;
45577
45578   {
45579     try {
45580       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45581     } catch (std::out_of_range& e) {
45582       {
45583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45584       };
45585     } catch (std::exception& e) {
45586       {
45587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45588       };
45589     } catch (...) {
45590       {
45591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45592       };
45593     }
45594   }
45595   jresult = (void *)result;
45596   return jresult;
45597 }
45598
45599
45600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45601   void * jresult ;
45602   int arg1 ;
45603   int arg2 ;
45604   int arg3 ;
45605   int arg4 ;
45606   Dali::Rect< int > *result = 0 ;
45607
45608   arg1 = (int)jarg1;
45609   arg2 = (int)jarg2;
45610   arg3 = (int)jarg3;
45611   arg4 = (int)jarg4;
45612   {
45613     try {
45614       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45615     } catch (std::out_of_range& e) {
45616       {
45617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45618       };
45619     } catch (std::exception& e) {
45620       {
45621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45622       };
45623     } catch (...) {
45624       {
45625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45626       };
45627     }
45628   }
45629   jresult = (void *)result;
45630   return jresult;
45631 }
45632
45633
45634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45635   void * jresult ;
45636   Dali::Rect< int > *arg1 = 0 ;
45637   Dali::Rect< int > *result = 0 ;
45638
45639   arg1 = (Dali::Rect< int > *)jarg1;
45640   if (!arg1) {
45641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45642     return 0;
45643   }
45644   {
45645     try {
45646       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45647     } catch (std::out_of_range& e) {
45648       {
45649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45650       };
45651     } catch (std::exception& e) {
45652       {
45653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45654       };
45655     } catch (...) {
45656       {
45657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45658       };
45659     }
45660   }
45661   jresult = (void *)result;
45662   return jresult;
45663 }
45664
45665
45666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45667   void * jresult ;
45668   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45669   Dali::Rect< int > *arg2 = 0 ;
45670   Dali::Rect< int > *result = 0 ;
45671
45672   arg1 = (Dali::Rect< int > *)jarg1;
45673   arg2 = (Dali::Rect< int > *)jarg2;
45674   if (!arg2) {
45675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45676     return 0;
45677   }
45678   {
45679     try {
45680       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45681     } catch (std::out_of_range& e) {
45682       {
45683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45684       };
45685     } catch (std::exception& e) {
45686       {
45687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45688       };
45689     } catch (...) {
45690       {
45691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45692       };
45693     }
45694   }
45695   jresult = (void *)result;
45696   return jresult;
45697 }
45698
45699
45700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45701   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45702   int arg2 ;
45703   int arg3 ;
45704   int arg4 ;
45705   int arg5 ;
45706
45707   arg1 = (Dali::Rect< int > *)jarg1;
45708   arg2 = (int)jarg2;
45709   arg3 = (int)jarg3;
45710   arg4 = (int)jarg4;
45711   arg5 = (int)jarg5;
45712   {
45713     try {
45714       (arg1)->Set(arg2,arg3,arg4,arg5);
45715     } catch (std::out_of_range& e) {
45716       {
45717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45718       };
45719     } catch (std::exception& e) {
45720       {
45721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45722       };
45723     } catch (...) {
45724       {
45725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45726       };
45727     }
45728   }
45729 }
45730
45731
45732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45733   unsigned int jresult ;
45734   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45735   bool result;
45736
45737   arg1 = (Dali::Rect< int > *)jarg1;
45738   {
45739     try {
45740       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
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 int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45761   int jresult ;
45762   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45763   int result;
45764
45765   arg1 = (Dali::Rect< int > *)jarg1;
45766   {
45767     try {
45768       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45769     } catch (std::out_of_range& e) {
45770       {
45771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45772       };
45773     } catch (std::exception& e) {
45774       {
45775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45776       };
45777     } catch (...) {
45778       {
45779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45780       };
45781     }
45782   }
45783   jresult = result;
45784   return jresult;
45785 }
45786
45787
45788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45789   int jresult ;
45790   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45791   int result;
45792
45793   arg1 = (Dali::Rect< int > *)jarg1;
45794   {
45795     try {
45796       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45797     } catch (std::out_of_range& e) {
45798       {
45799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45800       };
45801     } catch (std::exception& e) {
45802       {
45803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45804       };
45805     } catch (...) {
45806       {
45807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45808       };
45809     }
45810   }
45811   jresult = result;
45812   return jresult;
45813 }
45814
45815
45816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45817   int jresult ;
45818   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45819   int result;
45820
45821   arg1 = (Dali::Rect< int > *)jarg1;
45822   {
45823     try {
45824       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (...) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45836       };
45837     }
45838   }
45839   jresult = result;
45840   return jresult;
45841 }
45842
45843
45844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45845   int jresult ;
45846   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45847   int result;
45848
45849   arg1 = (Dali::Rect< int > *)jarg1;
45850   {
45851     try {
45852       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (...) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45864       };
45865     }
45866   }
45867   jresult = result;
45868   return jresult;
45869 }
45870
45871
45872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45873   int jresult ;
45874   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45875   int result;
45876
45877   arg1 = (Dali::Rect< int > *)jarg1;
45878   {
45879     try {
45880       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45881     } catch (std::out_of_range& e) {
45882       {
45883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45884       };
45885     } catch (std::exception& e) {
45886       {
45887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45888       };
45889     } catch (...) {
45890       {
45891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45892       };
45893     }
45894   }
45895   jresult = result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45901   unsigned int jresult ;
45902   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45903   Dali::Rect< int > *arg2 = 0 ;
45904   bool result;
45905
45906   arg1 = (Dali::Rect< int > *)jarg1;
45907   arg2 = (Dali::Rect< int > *)jarg2;
45908   if (!arg2) {
45909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45910     return 0;
45911   }
45912   {
45913     try {
45914       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45915     } catch (std::out_of_range& e) {
45916       {
45917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45918       };
45919     } catch (std::exception& e) {
45920       {
45921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45922       };
45923     } catch (...) {
45924       {
45925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45926       };
45927     }
45928   }
45929   jresult = result;
45930   return jresult;
45931 }
45932
45933
45934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45935   unsigned int jresult ;
45936   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45937   Dali::Rect< int > *arg2 = 0 ;
45938   bool result;
45939
45940   arg1 = (Dali::Rect< int > *)jarg1;
45941   arg2 = (Dali::Rect< int > *)jarg2;
45942   if (!arg2) {
45943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45944     return 0;
45945   }
45946   {
45947     try {
45948       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45949     } catch (std::out_of_range& e) {
45950       {
45951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45952       };
45953     } catch (std::exception& e) {
45954       {
45955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45956       };
45957     } catch (...) {
45958       {
45959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45960       };
45961     }
45962   }
45963   jresult = result;
45964   return jresult;
45965 }
45966
45967
45968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45969   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45970   int arg2 ;
45971
45972   arg1 = (Dali::Rect< int > *)jarg1;
45973   arg2 = (int)jarg2;
45974   if (arg1) (arg1)->x = arg2;
45975 }
45976
45977
45978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45979   int jresult ;
45980   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45981   int result;
45982
45983   arg1 = (Dali::Rect< int > *)jarg1;
45984   result = (int) ((arg1)->x);
45985   jresult = result;
45986   return jresult;
45987 }
45988
45989
45990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45991   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45992   int arg2 ;
45993
45994   arg1 = (Dali::Rect< int > *)jarg1;
45995   arg2 = (int)jarg2;
45996   if (arg1) (arg1)->left = arg2;
45997 }
45998
45999
46000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46001   int jresult ;
46002   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46003   int result;
46004
46005   arg1 = (Dali::Rect< int > *)jarg1;
46006   result = (int) ((arg1)->left);
46007   jresult = result;
46008   return jresult;
46009 }
46010
46011
46012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46013   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46014   int arg2 ;
46015
46016   arg1 = (Dali::Rect< int > *)jarg1;
46017   arg2 = (int)jarg2;
46018   if (arg1) (arg1)->y = arg2;
46019 }
46020
46021
46022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46023   int jresult ;
46024   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46025   int result;
46026
46027   arg1 = (Dali::Rect< int > *)jarg1;
46028   result = (int) ((arg1)->y);
46029   jresult = result;
46030   return jresult;
46031 }
46032
46033
46034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46035   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46036   int arg2 ;
46037
46038   arg1 = (Dali::Rect< int > *)jarg1;
46039   arg2 = (int)jarg2;
46040   if (arg1) (arg1)->right = arg2;
46041 }
46042
46043
46044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46045   int jresult ;
46046   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46047   int result;
46048
46049   arg1 = (Dali::Rect< int > *)jarg1;
46050   result = (int) ((arg1)->right);
46051   jresult = result;
46052   return jresult;
46053 }
46054
46055
46056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46057   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46058   int arg2 ;
46059
46060   arg1 = (Dali::Rect< int > *)jarg1;
46061   arg2 = (int)jarg2;
46062   if (arg1) (arg1)->width = arg2;
46063 }
46064
46065
46066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46067   int jresult ;
46068   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46069   int result;
46070
46071   arg1 = (Dali::Rect< int > *)jarg1;
46072   result = (int) ((arg1)->width);
46073   jresult = result;
46074   return jresult;
46075 }
46076
46077
46078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46079   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46080   int arg2 ;
46081
46082   arg1 = (Dali::Rect< int > *)jarg1;
46083   arg2 = (int)jarg2;
46084   if (arg1) (arg1)->bottom = arg2;
46085 }
46086
46087
46088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46089   int jresult ;
46090   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46091   int result;
46092
46093   arg1 = (Dali::Rect< int > *)jarg1;
46094   result = (int) ((arg1)->bottom);
46095   jresult = result;
46096   return jresult;
46097 }
46098
46099
46100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46101   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46102   int arg2 ;
46103
46104   arg1 = (Dali::Rect< int > *)jarg1;
46105   arg2 = (int)jarg2;
46106   if (arg1) (arg1)->height = arg2;
46107 }
46108
46109
46110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46111   int jresult ;
46112   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46113   int result;
46114
46115   arg1 = (Dali::Rect< int > *)jarg1;
46116   result = (int) ((arg1)->height);
46117   jresult = result;
46118   return jresult;
46119 }
46120
46121
46122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46123   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46124   int arg2 ;
46125
46126   arg1 = (Dali::Rect< int > *)jarg1;
46127   arg2 = (int)jarg2;
46128   if (arg1) (arg1)->top = arg2;
46129 }
46130
46131
46132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46133   int jresult ;
46134   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46135   int result;
46136
46137   arg1 = (Dali::Rect< int > *)jarg1;
46138   result = (int) ((arg1)->top);
46139   jresult = result;
46140   return jresult;
46141 }
46142
46143
46144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46145   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46146
46147   arg1 = (Dali::Rect< int > *)jarg1;
46148   {
46149     try {
46150       delete arg1;
46151     } catch (std::out_of_range& e) {
46152       {
46153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46154       };
46155     } catch (std::exception& e) {
46156       {
46157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46158       };
46159     } catch (...) {
46160       {
46161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46162       };
46163     }
46164   }
46165 }
46166
46167
46168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46169   void * jresult ;
46170   Dali::Rect< float > *result = 0 ;
46171
46172   {
46173     try {
46174       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46175     } catch (std::out_of_range& e) {
46176       {
46177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46178       };
46179     } catch (std::exception& e) {
46180       {
46181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46182       };
46183     } catch (...) {
46184       {
46185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46186       };
46187     }
46188   }
46189   jresult = (void *)result;
46190   return jresult;
46191 }
46192
46193
46194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46195   void * jresult ;
46196   float arg1 ;
46197   float arg2 ;
46198   float arg3 ;
46199   float arg4 ;
46200   Dali::Rect< float > *result = 0 ;
46201
46202   arg1 = (float)jarg1;
46203   arg2 = (float)jarg2;
46204   arg3 = (float)jarg3;
46205   arg4 = (float)jarg4;
46206   {
46207     try {
46208       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46209     } catch (std::out_of_range& e) {
46210       {
46211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46212       };
46213     } catch (std::exception& e) {
46214       {
46215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46216       };
46217     } catch (...) {
46218       {
46219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46220       };
46221     }
46222   }
46223   jresult = (void *)result;
46224   return jresult;
46225 }
46226
46227
46228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46229   void * jresult ;
46230   Dali::Rect< float > *arg1 = 0 ;
46231   Dali::Rect< float > *result = 0 ;
46232
46233   arg1 = (Dali::Rect< float > *)jarg1;
46234   if (!arg1) {
46235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46236     return 0;
46237   }
46238   {
46239     try {
46240       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46241     } catch (std::out_of_range& e) {
46242       {
46243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46244       };
46245     } catch (std::exception& e) {
46246       {
46247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46248       };
46249     } catch (...) {
46250       {
46251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46252       };
46253     }
46254   }
46255   jresult = (void *)result;
46256   return jresult;
46257 }
46258
46259
46260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46261   void * jresult ;
46262   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46263   Dali::Rect< float > *arg2 = 0 ;
46264   Dali::Rect< float > *result = 0 ;
46265
46266   arg1 = (Dali::Rect< float > *)jarg1;
46267   arg2 = (Dali::Rect< float > *)jarg2;
46268   if (!arg2) {
46269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46270     return 0;
46271   }
46272   {
46273     try {
46274       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46275     } catch (std::out_of_range& e) {
46276       {
46277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46278       };
46279     } catch (std::exception& e) {
46280       {
46281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46286       };
46287     }
46288   }
46289   jresult = (void *)result;
46290   return jresult;
46291 }
46292
46293
46294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46295   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46296   float arg2 ;
46297   float arg3 ;
46298   float arg4 ;
46299   float arg5 ;
46300
46301   arg1 = (Dali::Rect< float > *)jarg1;
46302   arg2 = (float)jarg2;
46303   arg3 = (float)jarg3;
46304   arg4 = (float)jarg4;
46305   arg5 = (float)jarg5;
46306   {
46307     try {
46308       (arg1)->Set(arg2,arg3,arg4,arg5);
46309     } catch (std::out_of_range& e) {
46310       {
46311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46312       };
46313     } catch (std::exception& e) {
46314       {
46315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46316       };
46317     } catch (...) {
46318       {
46319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46320       };
46321     }
46322   }
46323 }
46324
46325
46326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46327   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46328   float arg2 ;
46329
46330   arg1 = (Dali::Rect< float > *)jarg1;
46331   arg2 = (float)jarg2;
46332   if (arg1) (arg1)->x = arg2;
46333 }
46334
46335
46336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46337   float jresult ;
46338   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46339   float result;
46340
46341   arg1 = (Dali::Rect< float > *)jarg1;
46342   result = (float) ((arg1)->x);
46343   jresult = result;
46344   return jresult;
46345 }
46346
46347
46348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46349   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46350   float arg2 ;
46351
46352   arg1 = (Dali::Rect< float > *)jarg1;
46353   arg2 = (float)jarg2;
46354   if (arg1) (arg1)->left = arg2;
46355 }
46356
46357
46358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46359   float jresult ;
46360   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46361   float result;
46362
46363   arg1 = (Dali::Rect< float > *)jarg1;
46364   result = (float) ((arg1)->left);
46365   jresult = result;
46366   return jresult;
46367 }
46368
46369
46370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46371   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46372   float arg2 ;
46373
46374   arg1 = (Dali::Rect< float > *)jarg1;
46375   arg2 = (float)jarg2;
46376   if (arg1) (arg1)->y = arg2;
46377 }
46378
46379
46380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46381   float jresult ;
46382   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46383   float result;
46384
46385   arg1 = (Dali::Rect< float > *)jarg1;
46386   result = (float) ((arg1)->y);
46387   jresult = result;
46388   return jresult;
46389 }
46390
46391
46392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46393   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46394   float arg2 ;
46395
46396   arg1 = (Dali::Rect< float > *)jarg1;
46397   arg2 = (float)jarg2;
46398   if (arg1) (arg1)->right = arg2;
46399 }
46400
46401
46402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46403   float jresult ;
46404   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46405   float result;
46406
46407   arg1 = (Dali::Rect< float > *)jarg1;
46408   result = (float) ((arg1)->right);
46409   jresult = result;
46410   return jresult;
46411 }
46412
46413
46414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46415   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46416   float arg2 ;
46417
46418   arg1 = (Dali::Rect< float > *)jarg1;
46419   arg2 = (float)jarg2;
46420   if (arg1) (arg1)->width = arg2;
46421 }
46422
46423
46424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46425   float jresult ;
46426   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46427   float result;
46428
46429   arg1 = (Dali::Rect< float > *)jarg1;
46430   result = (float) ((arg1)->width);
46431   jresult = result;
46432   return jresult;
46433 }
46434
46435
46436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46437   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46438   float arg2 ;
46439
46440   arg1 = (Dali::Rect< float > *)jarg1;
46441   arg2 = (float)jarg2;
46442   if (arg1) (arg1)->bottom = arg2;
46443 }
46444
46445
46446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46447   float jresult ;
46448   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46449   float result;
46450
46451   arg1 = (Dali::Rect< float > *)jarg1;
46452   result = (float) ((arg1)->bottom);
46453   jresult = result;
46454   return jresult;
46455 }
46456
46457
46458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46459   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46460   float arg2 ;
46461
46462   arg1 = (Dali::Rect< float > *)jarg1;
46463   arg2 = (float)jarg2;
46464   if (arg1) (arg1)->height = arg2;
46465 }
46466
46467
46468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46469   float jresult ;
46470   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46471   float result;
46472
46473   arg1 = (Dali::Rect< float > *)jarg1;
46474   result = (float) ((arg1)->height);
46475   jresult = result;
46476   return jresult;
46477 }
46478
46479
46480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46481   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46482   float arg2 ;
46483
46484   arg1 = (Dali::Rect< float > *)jarg1;
46485   arg2 = (float)jarg2;
46486   if (arg1) (arg1)->top = arg2;
46487 }
46488
46489
46490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46491   float jresult ;
46492   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46493   float result;
46494
46495   arg1 = (Dali::Rect< float > *)jarg1;
46496   result = (float) ((arg1)->top);
46497   jresult = result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46503   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46504
46505   arg1 = (Dali::Rect< float > *)jarg1;
46506   {
46507     try {
46508       delete arg1;
46509     } catch (std::out_of_range& e) {
46510       {
46511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46512       };
46513     } catch (std::exception& e) {
46514       {
46515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46516       };
46517     } catch (...) {
46518       {
46519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46520       };
46521     }
46522   }
46523 }
46524
46525
46526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46527   int jresult ;
46528   int result;
46529
46530   result = (int)Dali::Vector< int >::BaseType;
46531   jresult = (int)result;
46532   return jresult;
46533 }
46534
46535
46536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46537   void * jresult ;
46538   Dali::Vector< int > *result = 0 ;
46539
46540   {
46541     try {
46542       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46543     } catch (std::out_of_range& e) {
46544       {
46545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46546       };
46547     } catch (std::exception& e) {
46548       {
46549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46550       };
46551     } catch (...) {
46552       {
46553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46554       };
46555     }
46556   }
46557   jresult = (void *)result;
46558   return jresult;
46559 }
46560
46561
46562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46563   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46564
46565   arg1 = (Dali::Vector< int > *)jarg1;
46566   {
46567     try {
46568       delete arg1;
46569     } catch (std::out_of_range& e) {
46570       {
46571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46572       };
46573     } catch (std::exception& e) {
46574       {
46575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46576       };
46577     } catch (...) {
46578       {
46579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46580       };
46581     }
46582   }
46583 }
46584
46585
46586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46587   void * jresult ;
46588   Dali::Vector< int > *arg1 = 0 ;
46589   Dali::Vector< int > *result = 0 ;
46590
46591   arg1 = (Dali::Vector< int > *)jarg1;
46592   if (!arg1) {
46593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46594     return 0;
46595   }
46596   {
46597     try {
46598       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46599     } catch (std::out_of_range& e) {
46600       {
46601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46602       };
46603     } catch (std::exception& e) {
46604       {
46605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (...) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46610       };
46611     }
46612   }
46613   jresult = (void *)result;
46614   return jresult;
46615 }
46616
46617
46618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46619   void * jresult ;
46620   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46621   Dali::Vector< int > *arg2 = 0 ;
46622   Dali::Vector< int > *result = 0 ;
46623
46624   arg1 = (Dali::Vector< int > *)jarg1;
46625   arg2 = (Dali::Vector< int > *)jarg2;
46626   if (!arg2) {
46627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46628     return 0;
46629   }
46630   {
46631     try {
46632       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46633     } catch (std::out_of_range& e) {
46634       {
46635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46636       };
46637     } catch (std::exception& e) {
46638       {
46639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46640       };
46641     } catch (...) {
46642       {
46643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46644       };
46645     }
46646   }
46647   jresult = (void *)result;
46648   return jresult;
46649 }
46650
46651
46652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46653   void * jresult ;
46654   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46655   Dali::Vector< int >::Iterator result;
46656
46657   arg1 = (Dali::Vector< int > *)jarg1;
46658   {
46659     try {
46660       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46661     } catch (std::out_of_range& e) {
46662       {
46663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46664       };
46665     } catch (std::exception& e) {
46666       {
46667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46668       };
46669     } catch (...) {
46670       {
46671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46672       };
46673     }
46674   }
46675   jresult = (void *)result;
46676   return jresult;
46677 }
46678
46679
46680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46681   void * jresult ;
46682   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46683   Dali::Vector< int >::Iterator result;
46684
46685   arg1 = (Dali::Vector< int > *)jarg1;
46686   {
46687     try {
46688       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46689     } catch (std::out_of_range& e) {
46690       {
46691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46692       };
46693     } catch (std::exception& e) {
46694       {
46695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (...) {
46698       {
46699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46700       };
46701     }
46702   }
46703   jresult = (void *)result;
46704   return jresult;
46705 }
46706
46707
46708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46709   void * jresult ;
46710   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46711   Dali::Vector< int >::SizeType arg2 ;
46712   Dali::Vector< int >::ItemType *result = 0 ;
46713
46714   arg1 = (Dali::Vector< int > *)jarg1;
46715   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46716   {
46717     try {
46718       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46719     } catch (std::out_of_range& e) {
46720       {
46721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46722       };
46723     } catch (std::exception& e) {
46724       {
46725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46726       };
46727     } catch (...) {
46728       {
46729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46730       };
46731     }
46732   }
46733   jresult = (void *)result;
46734   return jresult;
46735 }
46736
46737
46738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46739   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46740   Dali::Vector< int >::ItemType *arg2 = 0 ;
46741   Dali::Vector< int >::ItemType temp2 ;
46742
46743   arg1 = (Dali::Vector< int > *)jarg1;
46744   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46745   arg2 = &temp2;
46746   {
46747     try {
46748       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46749     } catch (std::out_of_range& e) {
46750       {
46751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46752       };
46753     } catch (std::exception& e) {
46754       {
46755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46756       };
46757     } catch (...) {
46758       {
46759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46760       };
46761     }
46762   }
46763 }
46764
46765
46766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46767   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46768   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46769   Dali::Vector< int >::ItemType *arg3 = 0 ;
46770   Dali::Vector< int >::ItemType temp3 ;
46771
46772   arg1 = (Dali::Vector< int > *)jarg1;
46773   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46774   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46775   arg3 = &temp3;
46776   {
46777     try {
46778       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46779     } catch (std::out_of_range& e) {
46780       {
46781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46782       };
46783     } catch (std::exception& e) {
46784       {
46785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46786       };
46787     } catch (...) {
46788       {
46789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46790       };
46791     }
46792   }
46793 }
46794
46795
46796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46797   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46798   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46799   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46800   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46801
46802   arg1 = (Dali::Vector< int > *)jarg1;
46803   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46804   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46805   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46806   {
46807     try {
46808       (arg1)->Insert(arg2,arg3,arg4);
46809     } catch (std::out_of_range& e) {
46810       {
46811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46812       };
46813     } catch (std::exception& e) {
46814       {
46815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46816       };
46817     } catch (...) {
46818       {
46819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46820       };
46821     }
46822   }
46823 }
46824
46825
46826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46827   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46828   Dali::Vector< int >::SizeType arg2 ;
46829
46830   arg1 = (Dali::Vector< int > *)jarg1;
46831   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46832   {
46833     try {
46834       (arg1)->Reserve(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_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46853   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46854   Dali::Vector< int >::SizeType arg2 ;
46855
46856   arg1 = (Dali::Vector< int > *)jarg1;
46857   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46858   {
46859     try {
46860       (arg1)->Resize(arg2);
46861     } catch (std::out_of_range& e) {
46862       {
46863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46864       };
46865     } catch (std::exception& e) {
46866       {
46867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46868       };
46869     } catch (...) {
46870       {
46871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46872       };
46873     }
46874   }
46875 }
46876
46877
46878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46879   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46880   Dali::Vector< int >::SizeType arg2 ;
46881   Dali::Vector< int >::ItemType *arg3 = 0 ;
46882   Dali::Vector< int >::ItemType temp3 ;
46883
46884   arg1 = (Dali::Vector< int > *)jarg1;
46885   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46886   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46887   arg3 = &temp3;
46888   {
46889     try {
46890       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46891     } catch (std::out_of_range& e) {
46892       {
46893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46894       };
46895     } catch (std::exception& e) {
46896       {
46897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46898       };
46899     } catch (...) {
46900       {
46901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46902       };
46903     }
46904   }
46905 }
46906
46907
46908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46909   void * jresult ;
46910   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46911   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46912   Dali::Vector< int >::Iterator result;
46913
46914   arg1 = (Dali::Vector< int > *)jarg1;
46915   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46916   {
46917     try {
46918       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46919     } catch (std::out_of_range& e) {
46920       {
46921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46922       };
46923     } catch (std::exception& e) {
46924       {
46925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46926       };
46927     } catch (...) {
46928       {
46929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46930       };
46931     }
46932   }
46933   jresult = (void *)result;
46934   return jresult;
46935 }
46936
46937
46938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46939   void * jresult ;
46940   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46941   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46942   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46943   Dali::Vector< int >::Iterator result;
46944
46945   arg1 = (Dali::Vector< int > *)jarg1;
46946   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46947   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46948   {
46949     try {
46950       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46951     } catch (std::out_of_range& e) {
46952       {
46953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46954       };
46955     } catch (std::exception& e) {
46956       {
46957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46958       };
46959     } catch (...) {
46960       {
46961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46962       };
46963     }
46964   }
46965   jresult = (void *)result;
46966   return jresult;
46967 }
46968
46969
46970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46971   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46972   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46973
46974   arg1 = (Dali::Vector< int > *)jarg1;
46975   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46976   {
46977     try {
46978       (arg1)->Remove(arg2);
46979     } catch (std::out_of_range& e) {
46980       {
46981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46982       };
46983     } catch (std::exception& e) {
46984       {
46985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46986       };
46987     } catch (...) {
46988       {
46989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46990       };
46991     }
46992   }
46993 }
46994
46995
46996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46997   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46998   Dali::Vector< int > *arg2 = 0 ;
46999
47000   arg1 = (Dali::Vector< int > *)jarg1;
47001   arg2 = (Dali::Vector< int > *)jarg2;
47002   if (!arg2) {
47003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47004     return ;
47005   }
47006   {
47007     try {
47008       (arg1)->Swap(*arg2);
47009     } catch (std::out_of_range& e) {
47010       {
47011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47012       };
47013     } catch (std::exception& e) {
47014       {
47015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47016       };
47017     } catch (...) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47020       };
47021     }
47022   }
47023 }
47024
47025
47026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47027   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47028
47029   arg1 = (Dali::Vector< int > *)jarg1;
47030   {
47031     try {
47032       (arg1)->Clear();
47033     } catch (std::out_of_range& e) {
47034       {
47035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47036       };
47037     } catch (std::exception& e) {
47038       {
47039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47040       };
47041     } catch (...) {
47042       {
47043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47044       };
47045     }
47046   }
47047 }
47048
47049
47050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47051   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47052
47053   arg1 = (Dali::Vector< int > *)jarg1;
47054   {
47055     try {
47056       (arg1)->Release();
47057     } catch (std::out_of_range& e) {
47058       {
47059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47060       };
47061     } catch (std::exception& e) {
47062       {
47063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47064       };
47065     } catch (...) {
47066       {
47067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47068       };
47069     }
47070   }
47071 }
47072
47073
47074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47075   int jresult ;
47076   int result;
47077
47078   result = (int)Dali::Vector< float >::BaseType;
47079   jresult = (int)result;
47080   return jresult;
47081 }
47082
47083
47084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47085   void * jresult ;
47086   Dali::Vector< float > *result = 0 ;
47087
47088   {
47089     try {
47090       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47091     } catch (std::out_of_range& e) {
47092       {
47093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47094       };
47095     } catch (std::exception& e) {
47096       {
47097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47098       };
47099     } catch (...) {
47100       {
47101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47102       };
47103     }
47104   }
47105   jresult = (void *)result;
47106   return jresult;
47107 }
47108
47109
47110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47111   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47112
47113   arg1 = (Dali::Vector< float > *)jarg1;
47114   {
47115     try {
47116       delete arg1;
47117     } catch (std::out_of_range& e) {
47118       {
47119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47120       };
47121     } catch (std::exception& e) {
47122       {
47123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47124       };
47125     } catch (...) {
47126       {
47127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47128       };
47129     }
47130   }
47131 }
47132
47133
47134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47135   void * jresult ;
47136   Dali::Vector< float > *arg1 = 0 ;
47137   Dali::Vector< float > *result = 0 ;
47138
47139   arg1 = (Dali::Vector< float > *)jarg1;
47140   if (!arg1) {
47141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47142     return 0;
47143   }
47144   {
47145     try {
47146       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47147     } catch (std::out_of_range& e) {
47148       {
47149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47150       };
47151     } catch (std::exception& e) {
47152       {
47153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47154       };
47155     } catch (...) {
47156       {
47157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47158       };
47159     }
47160   }
47161   jresult = (void *)result;
47162   return jresult;
47163 }
47164
47165
47166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47167   void * jresult ;
47168   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47169   Dali::Vector< float > *arg2 = 0 ;
47170   Dali::Vector< float > *result = 0 ;
47171
47172   arg1 = (Dali::Vector< float > *)jarg1;
47173   arg2 = (Dali::Vector< float > *)jarg2;
47174   if (!arg2) {
47175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47176     return 0;
47177   }
47178   {
47179     try {
47180       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47181     } catch (std::out_of_range& e) {
47182       {
47183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47184       };
47185     } catch (std::exception& e) {
47186       {
47187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47188       };
47189     } catch (...) {
47190       {
47191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47192       };
47193     }
47194   }
47195   jresult = (void *)result;
47196   return jresult;
47197 }
47198
47199
47200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47201   void * jresult ;
47202   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47203   Dali::Vector< float >::Iterator result;
47204
47205   arg1 = (Dali::Vector< float > *)jarg1;
47206   {
47207     try {
47208       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (...) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47220       };
47221     }
47222   }
47223   jresult = (void *)result;
47224   return jresult;
47225 }
47226
47227
47228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47229   void * jresult ;
47230   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47231   Dali::Vector< float >::Iterator result;
47232
47233   arg1 = (Dali::Vector< float > *)jarg1;
47234   {
47235     try {
47236       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47237     } catch (std::out_of_range& e) {
47238       {
47239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47240       };
47241     } catch (std::exception& e) {
47242       {
47243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47244       };
47245     } catch (...) {
47246       {
47247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47248       };
47249     }
47250   }
47251   jresult = (void *)result;
47252   return jresult;
47253 }
47254
47255
47256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47257   void * jresult ;
47258   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47259   Dali::Vector< float >::SizeType arg2 ;
47260   Dali::Vector< float >::ItemType *result = 0 ;
47261
47262   arg1 = (Dali::Vector< float > *)jarg1;
47263   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47264   {
47265     try {
47266       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47267     } catch (std::out_of_range& e) {
47268       {
47269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47270       };
47271     } catch (std::exception& e) {
47272       {
47273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47274       };
47275     } catch (...) {
47276       {
47277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47278       };
47279     }
47280   }
47281   jresult = (void *)result;
47282   return jresult;
47283 }
47284
47285
47286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47287   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47288   Dali::Vector< float >::ItemType *arg2 = 0 ;
47289   Dali::Vector< float >::ItemType temp2 ;
47290
47291   arg1 = (Dali::Vector< float > *)jarg1;
47292   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47293   arg2 = &temp2;
47294   {
47295     try {
47296       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47297     } catch (std::out_of_range& e) {
47298       {
47299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47300       };
47301     } catch (std::exception& e) {
47302       {
47303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47304       };
47305     } catch (...) {
47306       {
47307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47308       };
47309     }
47310   }
47311 }
47312
47313
47314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47315   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47316   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47317   Dali::Vector< float >::ItemType *arg3 = 0 ;
47318   Dali::Vector< float >::ItemType temp3 ;
47319
47320   arg1 = (Dali::Vector< float > *)jarg1;
47321   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47322   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47323   arg3 = &temp3;
47324   {
47325     try {
47326       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47327     } catch (std::out_of_range& e) {
47328       {
47329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47330       };
47331     } catch (std::exception& e) {
47332       {
47333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47334       };
47335     } catch (...) {
47336       {
47337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47338       };
47339     }
47340   }
47341 }
47342
47343
47344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47345   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47346   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47347   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47348   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47349
47350   arg1 = (Dali::Vector< float > *)jarg1;
47351   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47352   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47353   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47354   {
47355     try {
47356       (arg1)->Insert(arg2,arg3,arg4);
47357     } catch (std::out_of_range& e) {
47358       {
47359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47360       };
47361     } catch (std::exception& e) {
47362       {
47363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47364       };
47365     } catch (...) {
47366       {
47367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47368       };
47369     }
47370   }
47371 }
47372
47373
47374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47375   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47376   Dali::Vector< float >::SizeType arg2 ;
47377
47378   arg1 = (Dali::Vector< float > *)jarg1;
47379   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47380   {
47381     try {
47382       (arg1)->Reserve(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_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47401   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47402   Dali::Vector< float >::SizeType arg2 ;
47403
47404   arg1 = (Dali::Vector< float > *)jarg1;
47405   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47406   {
47407     try {
47408       (arg1)->Resize(arg2);
47409     } catch (std::out_of_range& e) {
47410       {
47411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47412       };
47413     } catch (std::exception& e) {
47414       {
47415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47416       };
47417     } catch (...) {
47418       {
47419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47420       };
47421     }
47422   }
47423 }
47424
47425
47426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47427   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47428   Dali::Vector< float >::SizeType arg2 ;
47429   Dali::Vector< float >::ItemType *arg3 = 0 ;
47430   Dali::Vector< float >::ItemType temp3 ;
47431
47432   arg1 = (Dali::Vector< float > *)jarg1;
47433   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47434   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47435   arg3 = &temp3;
47436   {
47437     try {
47438       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47439     } catch (std::out_of_range& e) {
47440       {
47441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47442       };
47443     } catch (std::exception& e) {
47444       {
47445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47446       };
47447     } catch (...) {
47448       {
47449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47450       };
47451     }
47452   }
47453 }
47454
47455
47456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47457   void * jresult ;
47458   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47459   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47460   Dali::Vector< float >::Iterator result;
47461
47462   arg1 = (Dali::Vector< float > *)jarg1;
47463   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47464   {
47465     try {
47466       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47467     } catch (std::out_of_range& e) {
47468       {
47469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47470       };
47471     } catch (std::exception& e) {
47472       {
47473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47474       };
47475     } catch (...) {
47476       {
47477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47478       };
47479     }
47480   }
47481   jresult = (void *)result;
47482   return jresult;
47483 }
47484
47485
47486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47487   void * jresult ;
47488   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47489   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47490   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47491   Dali::Vector< float >::Iterator result;
47492
47493   arg1 = (Dali::Vector< float > *)jarg1;
47494   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47495   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47496   {
47497     try {
47498       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47499     } catch (std::out_of_range& e) {
47500       {
47501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47502       };
47503     } catch (std::exception& e) {
47504       {
47505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47506       };
47507     } catch (...) {
47508       {
47509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47510       };
47511     }
47512   }
47513   jresult = (void *)result;
47514   return jresult;
47515 }
47516
47517
47518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47519   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47520   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47521
47522   arg1 = (Dali::Vector< float > *)jarg1;
47523   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47524   {
47525     try {
47526       (arg1)->Remove(arg2);
47527     } catch (std::out_of_range& e) {
47528       {
47529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (std::exception& e) {
47532       {
47533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47534       };
47535     } catch (...) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47538       };
47539     }
47540   }
47541 }
47542
47543
47544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47545   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47546   Dali::Vector< float > *arg2 = 0 ;
47547
47548   arg1 = (Dali::Vector< float > *)jarg1;
47549   arg2 = (Dali::Vector< float > *)jarg2;
47550   if (!arg2) {
47551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47552     return ;
47553   }
47554   {
47555     try {
47556       (arg1)->Swap(*arg2);
47557     } catch (std::out_of_range& e) {
47558       {
47559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47560       };
47561     } catch (std::exception& e) {
47562       {
47563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47564       };
47565     } catch (...) {
47566       {
47567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47568       };
47569     }
47570   }
47571 }
47572
47573
47574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47575   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47576
47577   arg1 = (Dali::Vector< float > *)jarg1;
47578   {
47579     try {
47580       (arg1)->Clear();
47581     } catch (std::out_of_range& e) {
47582       {
47583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47584       };
47585     } catch (std::exception& e) {
47586       {
47587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47588       };
47589     } catch (...) {
47590       {
47591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47592       };
47593     }
47594   }
47595 }
47596
47597
47598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47599   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47600
47601   arg1 = (Dali::Vector< float > *)jarg1;
47602   {
47603     try {
47604       (arg1)->Release();
47605     } catch (std::out_of_range& e) {
47606       {
47607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47608       };
47609     } catch (std::exception& e) {
47610       {
47611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47612       };
47613     } catch (...) {
47614       {
47615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47616       };
47617     }
47618   }
47619 }
47620
47621
47622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47623   int jresult ;
47624   int result;
47625
47626   result = (int)Dali::Vector< unsigned char >::BaseType;
47627   jresult = (int)result;
47628   return jresult;
47629 }
47630
47631
47632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47633   void * jresult ;
47634   Dali::Vector< unsigned char > *result = 0 ;
47635
47636   {
47637     try {
47638       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47639     } catch (std::out_of_range& e) {
47640       {
47641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47642       };
47643     } catch (std::exception& e) {
47644       {
47645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47646       };
47647     } catch (...) {
47648       {
47649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47650       };
47651     }
47652   }
47653   jresult = (void *)result;
47654   return jresult;
47655 }
47656
47657
47658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47659   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47660
47661   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47662   {
47663     try {
47664       delete arg1;
47665     } catch (std::out_of_range& e) {
47666       {
47667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47668       };
47669     } catch (std::exception& e) {
47670       {
47671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47676       };
47677     }
47678   }
47679 }
47680
47681
47682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47683   void * jresult ;
47684   Dali::Vector< unsigned char > *arg1 = 0 ;
47685   Dali::Vector< unsigned char > *result = 0 ;
47686
47687   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47688   if (!arg1) {
47689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47690     return 0;
47691   }
47692   {
47693     try {
47694       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47695     } catch (std::out_of_range& e) {
47696       {
47697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47698       };
47699     } catch (std::exception& e) {
47700       {
47701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47702       };
47703     } catch (...) {
47704       {
47705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47706       };
47707     }
47708   }
47709   jresult = (void *)result;
47710   return jresult;
47711 }
47712
47713
47714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47715   void * jresult ;
47716   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47717   Dali::Vector< unsigned char > *arg2 = 0 ;
47718   Dali::Vector< unsigned char > *result = 0 ;
47719
47720   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47721   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47722   if (!arg2) {
47723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47724     return 0;
47725   }
47726   {
47727     try {
47728       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47729     } catch (std::out_of_range& e) {
47730       {
47731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47732       };
47733     } catch (std::exception& e) {
47734       {
47735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47736       };
47737     } catch (...) {
47738       {
47739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47740       };
47741     }
47742   }
47743   jresult = (void *)result;
47744   return jresult;
47745 }
47746
47747
47748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47749   void * jresult ;
47750   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47751   Dali::Vector< unsigned char >::Iterator result;
47752
47753   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47754   {
47755     try {
47756       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47757     } catch (std::out_of_range& e) {
47758       {
47759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47760       };
47761     } catch (std::exception& e) {
47762       {
47763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47764       };
47765     } catch (...) {
47766       {
47767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47768       };
47769     }
47770   }
47771   jresult = (void *)result;
47772   return jresult;
47773 }
47774
47775
47776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47777   void * jresult ;
47778   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47779   Dali::Vector< unsigned char >::Iterator result;
47780
47781   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47782   {
47783     try {
47784       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47785     } catch (std::out_of_range& e) {
47786       {
47787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47788       };
47789     } catch (std::exception& e) {
47790       {
47791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47792       };
47793     } catch (...) {
47794       {
47795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47796       };
47797     }
47798   }
47799   jresult = (void *)result;
47800   return jresult;
47801 }
47802
47803
47804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47805   void * jresult ;
47806   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47807   Dali::Vector< unsigned char >::SizeType arg2 ;
47808   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47809
47810   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47811   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47812   {
47813     try {
47814       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47815     } catch (std::out_of_range& e) {
47816       {
47817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47818       };
47819     } catch (std::exception& e) {
47820       {
47821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47822       };
47823     } catch (...) {
47824       {
47825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47826       };
47827     }
47828   }
47829   jresult = (void *)result;
47830   return jresult;
47831 }
47832
47833
47834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47835   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47836   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47837   Dali::Vector< unsigned char >::ItemType temp2 ;
47838
47839   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47840   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47841   arg2 = &temp2;
47842   {
47843     try {
47844       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47845     } catch (std::out_of_range& e) {
47846       {
47847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47848       };
47849     } catch (std::exception& e) {
47850       {
47851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47852       };
47853     } catch (...) {
47854       {
47855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47856       };
47857     }
47858   }
47859 }
47860
47861
47862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47863   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47864   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47865   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47866   Dali::Vector< unsigned char >::ItemType temp3 ;
47867
47868   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47869   arg2 = jarg2;
47870   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47871   arg3 = &temp3;
47872   {
47873     try {
47874       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47875     } catch (std::out_of_range& e) {
47876       {
47877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47878       };
47879     } catch (std::exception& e) {
47880       {
47881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47882       };
47883     } catch (...) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47886       };
47887     }
47888   }
47889
47890
47891 }
47892
47893
47894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47895   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47896   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47897   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47898   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47899
47900   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47901   arg2 = jarg2;
47902   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47903   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47904   {
47905     try {
47906       (arg1)->Insert(arg2,arg3,arg4);
47907     } catch (std::out_of_range& e) {
47908       {
47909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47910       };
47911     } catch (std::exception& e) {
47912       {
47913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47914       };
47915     } catch (...) {
47916       {
47917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47918       };
47919     }
47920   }
47921
47922
47923 }
47924
47925
47926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47927   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47928   Dali::Vector< unsigned char >::SizeType arg2 ;
47929
47930   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47931   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47932   {
47933     try {
47934       (arg1)->Reserve(arg2);
47935     } catch (std::out_of_range& e) {
47936       {
47937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47938       };
47939     } catch (std::exception& e) {
47940       {
47941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47942       };
47943     } catch (...) {
47944       {
47945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47946       };
47947     }
47948   }
47949 }
47950
47951
47952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47953   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47954   Dali::Vector< unsigned char >::SizeType arg2 ;
47955
47956   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47957   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47958   {
47959     try {
47960       (arg1)->Resize(arg2);
47961     } catch (std::out_of_range& e) {
47962       {
47963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47964       };
47965     } catch (std::exception& e) {
47966       {
47967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47968       };
47969     } catch (...) {
47970       {
47971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47972       };
47973     }
47974   }
47975 }
47976
47977
47978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47979   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47980   Dali::Vector< unsigned char >::SizeType arg2 ;
47981   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47982   Dali::Vector< unsigned char >::ItemType temp3 ;
47983
47984   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47985   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47986   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47987   arg3 = &temp3;
47988   {
47989     try {
47990       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47991     } catch (std::out_of_range& e) {
47992       {
47993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47994       };
47995     } catch (std::exception& e) {
47996       {
47997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47998       };
47999     } catch (...) {
48000       {
48001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48002       };
48003     }
48004   }
48005 }
48006
48007
48008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48009   void * jresult ;
48010   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48011   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48012   Dali::Vector< unsigned char >::Iterator result;
48013
48014   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48015   arg2 = jarg2;
48016   {
48017     try {
48018       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48019     } catch (std::out_of_range& e) {
48020       {
48021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48022       };
48023     } catch (std::exception& e) {
48024       {
48025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48030       };
48031     }
48032   }
48033   jresult = (void *)result;
48034
48035
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48041   void * jresult ;
48042   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48043   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48044   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48045   Dali::Vector< unsigned char >::Iterator result;
48046
48047   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48048   arg2 = jarg2;
48049   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48050   {
48051     try {
48052       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48053     } catch (std::out_of_range& e) {
48054       {
48055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48056       };
48057     } catch (std::exception& e) {
48058       {
48059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48060       };
48061     } catch (...) {
48062       {
48063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48064       };
48065     }
48066   }
48067   jresult = (void *)result;
48068
48069
48070   return jresult;
48071 }
48072
48073
48074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48075   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48076   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48077
48078   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48079   arg2 = jarg2;
48080   {
48081     try {
48082       (arg1)->Remove(arg2);
48083     } catch (std::out_of_range& e) {
48084       {
48085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48086       };
48087     } catch (std::exception& e) {
48088       {
48089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48090       };
48091     } catch (...) {
48092       {
48093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48094       };
48095     }
48096   }
48097
48098
48099 }
48100
48101
48102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48103   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48104   Dali::Vector< unsigned char > *arg2 = 0 ;
48105
48106   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48107   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48108   if (!arg2) {
48109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48110     return ;
48111   }
48112   {
48113     try {
48114       (arg1)->Swap(*arg2);
48115     } catch (std::out_of_range& e) {
48116       {
48117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48118       };
48119     } catch (std::exception& e) {
48120       {
48121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48122       };
48123     } catch (...) {
48124       {
48125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48126       };
48127     }
48128   }
48129 }
48130
48131
48132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48133   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48134
48135   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48136   {
48137     try {
48138       (arg1)->Clear();
48139     } catch (std::out_of_range& e) {
48140       {
48141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48142       };
48143     } catch (std::exception& e) {
48144       {
48145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48146       };
48147     } catch (...) {
48148       {
48149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48150       };
48151     }
48152   }
48153 }
48154
48155
48156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48157   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48158
48159   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48160   {
48161     try {
48162       (arg1)->Release();
48163     } catch (std::out_of_range& e) {
48164       {
48165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48166       };
48167     } catch (std::exception& e) {
48168       {
48169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (...) {
48172       {
48173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48174       };
48175     }
48176   }
48177 }
48178
48179
48180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48181   int jresult ;
48182   int result;
48183
48184   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48185   jresult = (int)result;
48186   return jresult;
48187 }
48188
48189
48190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48191   void * jresult ;
48192   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48193
48194   {
48195     try {
48196       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48197     } catch (std::out_of_range& e) {
48198       {
48199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48200       };
48201     } catch (std::exception& e) {
48202       {
48203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48204       };
48205     } catch (...) {
48206       {
48207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48208       };
48209     }
48210   }
48211   jresult = (void *)result;
48212   return jresult;
48213 }
48214
48215
48216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48217   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48218
48219   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48220   {
48221     try {
48222       delete arg1;
48223     } catch (std::out_of_range& e) {
48224       {
48225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48226       };
48227     } catch (std::exception& e) {
48228       {
48229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (...) {
48232       {
48233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48234       };
48235     }
48236   }
48237 }
48238
48239
48240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48241   void * jresult ;
48242   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48243   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48244
48245   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48246   if (!arg1) {
48247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48248     return 0;
48249   }
48250   {
48251     try {
48252       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48253     } catch (std::out_of_range& e) {
48254       {
48255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48256       };
48257     } catch (std::exception& e) {
48258       {
48259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48260       };
48261     } catch (...) {
48262       {
48263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48264       };
48265     }
48266   }
48267   jresult = (void *)result;
48268   return jresult;
48269 }
48270
48271
48272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48273   void * jresult ;
48274   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48275   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48276   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48277
48278   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48279   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48280   if (!arg2) {
48281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48282     return 0;
48283   }
48284   {
48285     try {
48286       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48287     } catch (std::out_of_range& e) {
48288       {
48289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48290       };
48291     } catch (std::exception& e) {
48292       {
48293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48294       };
48295     } catch (...) {
48296       {
48297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48298       };
48299     }
48300   }
48301   jresult = (void *)result;
48302   return jresult;
48303 }
48304
48305
48306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48307   void * jresult ;
48308   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48309   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48310
48311   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48312   {
48313     try {
48314       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48315     } catch (std::out_of_range& e) {
48316       {
48317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48318       };
48319     } catch (std::exception& e) {
48320       {
48321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48326       };
48327     }
48328   }
48329   jresult = (void *)result;
48330   return jresult;
48331 }
48332
48333
48334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48335   void * jresult ;
48336   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48337   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48338
48339   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48340   {
48341     try {
48342       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48343     } catch (std::out_of_range& e) {
48344       {
48345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48346       };
48347     } catch (std::exception& e) {
48348       {
48349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48350       };
48351     } catch (...) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48354       };
48355     }
48356   }
48357   jresult = (void *)result;
48358   return jresult;
48359 }
48360
48361
48362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48363   void * jresult ;
48364   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48365   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48366   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48367
48368   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48369   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48370   {
48371     try {
48372       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48373     } catch (std::out_of_range& e) {
48374       {
48375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48376       };
48377     } catch (std::exception& e) {
48378       {
48379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48380       };
48381     } catch (...) {
48382       {
48383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48384       };
48385     }
48386   }
48387   jresult = (void *)result;
48388   return jresult;
48389 }
48390
48391
48392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48393   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48394   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48395
48396   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48397   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48398   if (!arg2) {
48399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48400     return ;
48401   }
48402   {
48403     try {
48404       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48405     } catch (std::out_of_range& e) {
48406       {
48407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48408       };
48409     } catch (std::exception& e) {
48410       {
48411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48412       };
48413     } catch (...) {
48414       {
48415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48416       };
48417     }
48418   }
48419 }
48420
48421
48422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48423   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48424   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48425   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48426
48427   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48428   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48429   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48430   if (!arg3) {
48431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48432     return ;
48433   }
48434   {
48435     try {
48436       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48437     } catch (std::out_of_range& e) {
48438       {
48439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48440       };
48441     } catch (std::exception& e) {
48442       {
48443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48444       };
48445     } catch (...) {
48446       {
48447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48448       };
48449     }
48450   }
48451 }
48452
48453
48454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48455   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48456   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48457   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48458   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48459
48460   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48461   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48462   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48463   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48464   {
48465     try {
48466       (arg1)->Insert(arg2,arg3,arg4);
48467     } catch (std::out_of_range& e) {
48468       {
48469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48470       };
48471     } catch (std::exception& e) {
48472       {
48473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48474       };
48475     } catch (...) {
48476       {
48477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48478       };
48479     }
48480   }
48481 }
48482
48483
48484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48485   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48486   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48487
48488   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48489   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48490   {
48491     try {
48492       (arg1)->Reserve(arg2);
48493     } catch (std::out_of_range& e) {
48494       {
48495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48496       };
48497     } catch (std::exception& e) {
48498       {
48499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48500       };
48501     } catch (...) {
48502       {
48503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48504       };
48505     }
48506   }
48507 }
48508
48509
48510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48511   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48512   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48513
48514   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48515   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48516   {
48517     try {
48518       (arg1)->Resize(arg2);
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_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48537   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48538   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48539   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48540
48541   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48542   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48543   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48544   if (!arg3) {
48545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48546     return ;
48547   }
48548   {
48549     try {
48550       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (...) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48562       };
48563     }
48564   }
48565 }
48566
48567
48568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48569   void * jresult ;
48570   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48571   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48572   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48573
48574   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48575   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48576   {
48577     try {
48578       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48579     } catch (std::out_of_range& e) {
48580       {
48581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48582       };
48583     } catch (std::exception& e) {
48584       {
48585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48586       };
48587     } catch (...) {
48588       {
48589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48590       };
48591     }
48592   }
48593   jresult = (void *)result;
48594   return jresult;
48595 }
48596
48597
48598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48599   void * jresult ;
48600   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48601   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48602   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48603   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48604
48605   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48606   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48607   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48608   {
48609     try {
48610       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48611     } catch (std::out_of_range& e) {
48612       {
48613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48614       };
48615     } catch (std::exception& e) {
48616       {
48617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48618       };
48619     } catch (...) {
48620       {
48621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48622       };
48623     }
48624   }
48625   jresult = (void *)result;
48626   return jresult;
48627 }
48628
48629
48630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48631   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48632   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48633
48634   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48635   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48636   {
48637     try {
48638       (arg1)->Remove(arg2);
48639     } catch (std::out_of_range& e) {
48640       {
48641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48642       };
48643     } catch (std::exception& e) {
48644       {
48645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48646       };
48647     } catch (...) {
48648       {
48649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48650       };
48651     }
48652   }
48653 }
48654
48655
48656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48657   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48658   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48659
48660   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48661   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48662   if (!arg2) {
48663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48664     return ;
48665   }
48666   {
48667     try {
48668       (arg1)->Swap(*arg2);
48669     } catch (std::out_of_range& e) {
48670       {
48671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48672       };
48673     } catch (std::exception& e) {
48674       {
48675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48676       };
48677     } catch (...) {
48678       {
48679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48680       };
48681     }
48682   }
48683 }
48684
48685
48686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48687   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48688
48689   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48690   {
48691     try {
48692       (arg1)->Clear();
48693     } catch (std::out_of_range& e) {
48694       {
48695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48696       };
48697     } catch (std::exception& e) {
48698       {
48699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48700       };
48701     } catch (...) {
48702       {
48703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48704       };
48705     }
48706   }
48707 }
48708
48709
48710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48711   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48712
48713   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48714   {
48715     try {
48716       (arg1)->Release();
48717     } catch (std::out_of_range& e) {
48718       {
48719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48720       };
48721     } catch (std::exception& e) {
48722       {
48723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48724       };
48725     } catch (...) {
48726       {
48727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48728       };
48729     }
48730   }
48731 }
48732
48733
48734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48735   void * jresult ;
48736   Dali::Signal< void () > *result = 0 ;
48737
48738   {
48739     try {
48740       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48741     } catch (std::out_of_range& e) {
48742       {
48743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48744       };
48745     } catch (std::exception& e) {
48746       {
48747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48748       };
48749     } catch (...) {
48750       {
48751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48752       };
48753     }
48754   }
48755   jresult = (void *)result;
48756   return jresult;
48757 }
48758
48759
48760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48761   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48762
48763   arg1 = (Dali::Signal< void () > *)jarg1;
48764   {
48765     try {
48766       delete arg1;
48767     } catch (std::out_of_range& e) {
48768       {
48769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48770       };
48771     } catch (std::exception& e) {
48772       {
48773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48774       };
48775     } catch (...) {
48776       {
48777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48778       };
48779     }
48780   }
48781 }
48782
48783
48784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48785   unsigned int jresult ;
48786   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48787   bool result;
48788
48789   arg1 = (Dali::Signal< void () > *)jarg1;
48790   {
48791     try {
48792       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48793     } catch (std::out_of_range& e) {
48794       {
48795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48796       };
48797     } catch (std::exception& e) {
48798       {
48799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48800       };
48801     } catch (...) {
48802       {
48803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48804       };
48805     }
48806   }
48807   jresult = result;
48808   return jresult;
48809 }
48810
48811
48812 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48813   unsigned long jresult ;
48814   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48815   std::size_t result;
48816
48817   arg1 = (Dali::Signal< void () > *)jarg1;
48818   {
48819     try {
48820       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48821     } catch (std::out_of_range& e) {
48822       {
48823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48824       };
48825     } catch (std::exception& e) {
48826       {
48827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48828       };
48829     } catch (...) {
48830       {
48831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48832       };
48833     }
48834   }
48835   jresult = (unsigned long)result;
48836   return jresult;
48837 }
48838
48839
48840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48841   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48842   void (*arg2)() = (void (*)()) 0 ;
48843
48844   arg1 = (Dali::Signal< void () > *)jarg1;
48845   arg2 = (void (*)())jarg2;
48846   {
48847     try {
48848       (arg1)->Connect(arg2);
48849     } catch (std::out_of_range& e) {
48850       {
48851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48852       };
48853     } catch (std::exception& e) {
48854       {
48855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48856       };
48857     } catch (...) {
48858       {
48859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48860       };
48861     }
48862   }
48863 }
48864
48865
48866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48867   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48868   void (*arg2)() = (void (*)()) 0 ;
48869
48870   arg1 = (Dali::Signal< void () > *)jarg1;
48871   arg2 = (void (*)())jarg2;
48872   {
48873     try {
48874       (arg1)->Disconnect(arg2);
48875     } catch (std::out_of_range& e) {
48876       {
48877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48878       };
48879     } catch (std::exception& e) {
48880       {
48881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48882       };
48883     } catch (...) {
48884       {
48885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48886       };
48887     }
48888   }
48889 }
48890
48891
48892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48893   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48894   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48895   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48896
48897   arg1 = (Dali::Signal< void () > *)jarg1;
48898   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48899   arg3 = (Dali::FunctorDelegate *)jarg3;
48900   {
48901     try {
48902       (arg1)->Connect(arg2,arg3);
48903     } catch (std::out_of_range& e) {
48904       {
48905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48906       };
48907     } catch (std::exception& e) {
48908       {
48909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48910       };
48911     } catch (...) {
48912       {
48913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48914       };
48915     }
48916   }
48917 }
48918
48919
48920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48921   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48922
48923   arg1 = (Dali::Signal< void () > *)jarg1;
48924   {
48925     try {
48926       (arg1)->Emit();
48927     } catch (std::out_of_range& e) {
48928       {
48929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48930       };
48931     } catch (std::exception& e) {
48932       {
48933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48934       };
48935     } catch (...) {
48936       {
48937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48938       };
48939     }
48940   }
48941 }
48942
48943
48944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48945   unsigned int jresult ;
48946   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48947   bool result;
48948
48949   arg1 = (Dali::Signal< void (float) > *)jarg1;
48950   {
48951     try {
48952       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48953     } catch (std::out_of_range& e) {
48954       {
48955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48956       };
48957     } catch (std::exception& e) {
48958       {
48959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48960       };
48961     } catch (...) {
48962       {
48963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48964       };
48965     }
48966   }
48967   jresult = result;
48968   return jresult;
48969 }
48970
48971
48972 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48973   unsigned long jresult ;
48974   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48975   std::size_t result;
48976
48977   arg1 = (Dali::Signal< void (float) > *)jarg1;
48978   {
48979     try {
48980       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48981     } catch (std::out_of_range& e) {
48982       {
48983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48984       };
48985     } catch (std::exception& e) {
48986       {
48987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48988       };
48989     } catch (...) {
48990       {
48991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48992       };
48993     }
48994   }
48995   jresult = (unsigned long)result;
48996   return jresult;
48997 }
48998
48999
49000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49001   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49002   void (*arg2)(float) = (void (*)(float)) 0 ;
49003
49004   arg1 = (Dali::Signal< void (float) > *)jarg1;
49005   arg2 = (void (*)(float))jarg2;
49006   {
49007     try {
49008       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49009     } catch (std::out_of_range& e) {
49010       {
49011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49012       };
49013     } catch (std::exception& e) {
49014       {
49015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49016       };
49017     } catch (...) {
49018       {
49019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49020       };
49021     }
49022   }
49023 }
49024
49025
49026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49027   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49028   void (*arg2)(float) = (void (*)(float)) 0 ;
49029
49030   arg1 = (Dali::Signal< void (float) > *)jarg1;
49031   arg2 = (void (*)(float))jarg2;
49032   {
49033     try {
49034       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49035     } catch (std::out_of_range& e) {
49036       {
49037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49038       };
49039     } catch (std::exception& e) {
49040       {
49041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49042       };
49043     } catch (...) {
49044       {
49045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49046       };
49047     }
49048   }
49049 }
49050
49051
49052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49053   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49054   float arg2 ;
49055
49056   arg1 = (Dali::Signal< void (float) > *)jarg1;
49057   arg2 = (float)jarg2;
49058   {
49059     try {
49060       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49061     } catch (std::out_of_range& e) {
49062       {
49063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49064       };
49065     } catch (std::exception& e) {
49066       {
49067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49068       };
49069     } catch (...) {
49070       {
49071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49072       };
49073     }
49074   }
49075 }
49076
49077
49078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49079   void * jresult ;
49080   Dali::Signal< void (float) > *result = 0 ;
49081
49082   {
49083     try {
49084       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49085     } catch (std::out_of_range& e) {
49086       {
49087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49088       };
49089     } catch (std::exception& e) {
49090       {
49091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49092       };
49093     } catch (...) {
49094       {
49095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49096       };
49097     }
49098   }
49099   jresult = (void *)result;
49100   return jresult;
49101 }
49102
49103
49104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49105   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49106
49107   arg1 = (Dali::Signal< void (float) > *)jarg1;
49108   {
49109     try {
49110       delete arg1;
49111     } catch (std::out_of_range& e) {
49112       {
49113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49114       };
49115     } catch (std::exception& e) {
49116       {
49117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49118       };
49119     } catch (...) {
49120       {
49121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49122       };
49123     }
49124   }
49125 }
49126
49127
49128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49129   unsigned int jresult ;
49130   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49131   bool result;
49132
49133   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49134   {
49135     try {
49136       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49137     } catch (std::out_of_range& e) {
49138       {
49139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49140       };
49141     } catch (std::exception& e) {
49142       {
49143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49144       };
49145     } catch (...) {
49146       {
49147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49148       };
49149     }
49150   }
49151   jresult = result;
49152   return jresult;
49153 }
49154
49155
49156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49157   unsigned long jresult ;
49158   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49159   std::size_t result;
49160
49161   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49162   {
49163     try {
49164       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49165     } catch (std::out_of_range& e) {
49166       {
49167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49168       };
49169     } catch (std::exception& e) {
49170       {
49171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49172       };
49173     } catch (...) {
49174       {
49175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49176       };
49177     }
49178   }
49179   jresult = (unsigned long)result;
49180   return jresult;
49181 }
49182
49183
49184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49185   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49186   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49187
49188   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49189   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49190   {
49191     try {
49192       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49193     } catch (std::out_of_range& e) {
49194       {
49195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49196       };
49197     } catch (std::exception& e) {
49198       {
49199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49200       };
49201     } catch (...) {
49202       {
49203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49204       };
49205     }
49206   }
49207 }
49208
49209
49210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49211   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49212   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49213
49214   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49215   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49216   {
49217     try {
49218       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49219     } catch (std::out_of_range& e) {
49220       {
49221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49222       };
49223     } catch (std::exception& e) {
49224       {
49225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49226       };
49227     } catch (...) {
49228       {
49229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49230       };
49231     }
49232   }
49233 }
49234
49235
49236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49237   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49238   Dali::BaseHandle arg2 ;
49239   Dali::BaseHandle *argp2 ;
49240
49241   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49242   argp2 = (Dali::BaseHandle *)jarg2;
49243   if (!argp2) {
49244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49245     return ;
49246   }
49247   arg2 = *argp2;
49248   {
49249     try {
49250       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49251     } catch (std::out_of_range& e) {
49252       {
49253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49254       };
49255     } catch (std::exception& e) {
49256       {
49257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49258       };
49259     } catch (...) {
49260       {
49261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49262       };
49263     }
49264   }
49265 }
49266
49267
49268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49269   void * jresult ;
49270   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49271
49272   {
49273     try {
49274       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49275     } catch (std::out_of_range& e) {
49276       {
49277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49278       };
49279     } catch (std::exception& e) {
49280       {
49281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49282       };
49283     } catch (...) {
49284       {
49285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49286       };
49287     }
49288   }
49289   jresult = (void *)result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49295   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49296
49297   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49298   {
49299     try {
49300       delete arg1;
49301     } catch (std::out_of_range& e) {
49302       {
49303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49304       };
49305     } catch (std::exception& e) {
49306       {
49307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49308       };
49309     } catch (...) {
49310       {
49311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49312       };
49313     }
49314   }
49315 }
49316
49317
49318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49319   unsigned int jresult ;
49320   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49321   bool result;
49322
49323   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49324   {
49325     try {
49326       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49327     } catch (std::out_of_range& e) {
49328       {
49329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49330       };
49331     } catch (std::exception& e) {
49332       {
49333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49334       };
49335     } catch (...) {
49336       {
49337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49338       };
49339     }
49340   }
49341   jresult = result;
49342   return jresult;
49343 }
49344
49345
49346 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49347   unsigned long jresult ;
49348   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49349   std::size_t result;
49350
49351   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49352   {
49353     try {
49354       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49355     } catch (std::out_of_range& e) {
49356       {
49357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49358       };
49359     } catch (std::exception& e) {
49360       {
49361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49362       };
49363     } catch (...) {
49364       {
49365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49366       };
49367     }
49368   }
49369   jresult = (unsigned long)result;
49370   return jresult;
49371 }
49372
49373
49374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49375   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49376   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49377
49378   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49379   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49380   {
49381     try {
49382       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49383     } catch (std::out_of_range& e) {
49384       {
49385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49386       };
49387     } catch (std::exception& e) {
49388       {
49389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49390       };
49391     } catch (...) {
49392       {
49393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49394       };
49395     }
49396   }
49397 }
49398
49399
49400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49401   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49402   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49403
49404   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49405   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49406   {
49407     try {
49408       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49409     } catch (std::out_of_range& e) {
49410       {
49411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49412       };
49413     } catch (std::exception& e) {
49414       {
49415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49416       };
49417     } catch (...) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49420       };
49421     }
49422   }
49423 }
49424
49425
49426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49427   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49428   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49429
49430   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49431   arg2 = (Dali::RefObject *)jarg2;
49432   {
49433     try {
49434       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49435     } catch (std::out_of_range& e) {
49436       {
49437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49438       };
49439     } catch (std::exception& e) {
49440       {
49441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49442       };
49443     } catch (...) {
49444       {
49445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49446       };
49447     }
49448   }
49449 }
49450
49451
49452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49453   void * jresult ;
49454   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49455
49456   {
49457     try {
49458       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49459     } catch (std::out_of_range& e) {
49460       {
49461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (std::exception& e) {
49464       {
49465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (...) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49470       };
49471     }
49472   }
49473   jresult = (void *)result;
49474   return jresult;
49475 }
49476
49477
49478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49479   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49480
49481   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49482   {
49483     try {
49484       delete arg1;
49485     } catch (std::out_of_range& e) {
49486       {
49487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49488       };
49489     } catch (std::exception& e) {
49490       {
49491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49492       };
49493     } catch (...) {
49494       {
49495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49496       };
49497     }
49498   }
49499 }
49500
49501
49502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49503   unsigned int jresult ;
49504   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49505   bool result;
49506
49507   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49508   {
49509     try {
49510       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49511     } catch (std::out_of_range& e) {
49512       {
49513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49514       };
49515     } catch (std::exception& e) {
49516       {
49517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49518       };
49519     } catch (...) {
49520       {
49521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49522       };
49523     }
49524   }
49525   jresult = result;
49526   return jresult;
49527 }
49528
49529
49530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49531   unsigned long jresult ;
49532   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49533   std::size_t result;
49534
49535   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49536   {
49537     try {
49538       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49539     } catch (std::out_of_range& e) {
49540       {
49541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49542       };
49543     } catch (std::exception& e) {
49544       {
49545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49546       };
49547     } catch (...) {
49548       {
49549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49550       };
49551     }
49552   }
49553   jresult = (unsigned long)result;
49554   return jresult;
49555 }
49556
49557
49558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49559   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49560   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49561
49562   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49563   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49564   {
49565     try {
49566       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49567     } catch (std::out_of_range& e) {
49568       {
49569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49570       };
49571     } catch (std::exception& e) {
49572       {
49573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49574       };
49575     } catch (...) {
49576       {
49577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49578       };
49579     }
49580   }
49581 }
49582
49583
49584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49585   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49586   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49587
49588   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49589   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49590   {
49591     try {
49592       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49593     } catch (std::out_of_range& e) {
49594       {
49595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49596       };
49597     } catch (std::exception& e) {
49598       {
49599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49600       };
49601     } catch (...) {
49602       {
49603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49604       };
49605     }
49606   }
49607 }
49608
49609
49610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49611   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49612   Dali::PropertyNotification *arg2 = 0 ;
49613
49614   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49615   arg2 = (Dali::PropertyNotification *)jarg2;
49616   if (!arg2) {
49617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49618     return ;
49619   }
49620   {
49621     try {
49622       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49623     } catch (std::out_of_range& e) {
49624       {
49625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49626       };
49627     } catch (std::exception& e) {
49628       {
49629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49634       };
49635     }
49636   }
49637 }
49638
49639
49640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49641   void * jresult ;
49642   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49643
49644   {
49645     try {
49646       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49647     } catch (std::out_of_range& e) {
49648       {
49649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49650       };
49651     } catch (std::exception& e) {
49652       {
49653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49654       };
49655     } catch (...) {
49656       {
49657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49658       };
49659     }
49660   }
49661   jresult = (void *)result;
49662   return jresult;
49663 }
49664
49665
49666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49667   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49668
49669   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49670   {
49671     try {
49672       delete arg1;
49673     } catch (std::out_of_range& e) {
49674       {
49675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49676       };
49677     } catch (std::exception& e) {
49678       {
49679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (...) {
49682       {
49683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49684       };
49685     }
49686   }
49687 }
49688
49689
49690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49691   unsigned int jresult ;
49692   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49693   bool result;
49694
49695   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49696   {
49697     try {
49698       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49699     } catch (std::out_of_range& e) {
49700       {
49701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49702       };
49703     } catch (std::exception& e) {
49704       {
49705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49706       };
49707     } catch (...) {
49708       {
49709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49710       };
49711     }
49712   }
49713   jresult = result;
49714   return jresult;
49715 }
49716
49717
49718 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49719   unsigned long jresult ;
49720   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49721   std::size_t result;
49722
49723   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49724   {
49725     try {
49726       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49727     } catch (std::out_of_range& e) {
49728       {
49729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49730       };
49731     } catch (std::exception& e) {
49732       {
49733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49734       };
49735     } catch (...) {
49736       {
49737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49738       };
49739     }
49740   }
49741   jresult = (unsigned long)result;
49742   return jresult;
49743 }
49744
49745
49746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49747   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49748   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49749
49750   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49751   arg2 = (void (*)(Dali::Image))jarg2;
49752   {
49753     try {
49754       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49755     } catch (std::out_of_range& e) {
49756       {
49757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (std::exception& e) {
49760       {
49761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (...) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49766       };
49767     }
49768   }
49769 }
49770
49771
49772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49773   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49774   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49775
49776   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49777   arg2 = (void (*)(Dali::Image))jarg2;
49778   {
49779     try {
49780       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49781     } catch (std::out_of_range& e) {
49782       {
49783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49784       };
49785     } catch (std::exception& e) {
49786       {
49787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49788       };
49789     } catch (...) {
49790       {
49791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49792       };
49793     }
49794   }
49795 }
49796
49797
49798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49799   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49800   Dali::Image arg2 ;
49801   Dali::Image *argp2 ;
49802
49803   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49804   argp2 = (Dali::Image *)jarg2;
49805   if (!argp2) {
49806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49807     return ;
49808   }
49809   arg2 = *argp2;
49810   {
49811     try {
49812       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49813     } catch (std::out_of_range& e) {
49814       {
49815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49816       };
49817     } catch (std::exception& e) {
49818       {
49819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49820       };
49821     } catch (...) {
49822       {
49823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49824       };
49825     }
49826   }
49827 }
49828
49829
49830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49831   void * jresult ;
49832   Dali::Signal< void (Dali::Image) > *result = 0 ;
49833
49834   {
49835     try {
49836       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49837     } catch (std::out_of_range& e) {
49838       {
49839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49840       };
49841     } catch (std::exception& e) {
49842       {
49843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49844       };
49845     } catch (...) {
49846       {
49847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49848       };
49849     }
49850   }
49851   jresult = (void *)result;
49852   return jresult;
49853 }
49854
49855
49856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49857   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49858
49859   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49860   {
49861     try {
49862       delete arg1;
49863     } catch (std::out_of_range& e) {
49864       {
49865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49866       };
49867     } catch (std::exception& e) {
49868       {
49869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49870       };
49871     } catch (...) {
49872       {
49873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49874       };
49875     }
49876   }
49877 }
49878
49879
49880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49881   void * jresult ;
49882   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49883
49884   {
49885     try {
49886       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49887     } catch (std::out_of_range& e) {
49888       {
49889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49890       };
49891     } catch (std::exception& e) {
49892       {
49893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49894       };
49895     } catch (...) {
49896       {
49897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49898       };
49899     }
49900   }
49901   jresult = (void *)result;
49902   return jresult;
49903 }
49904
49905
49906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49907   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49908
49909   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49910   {
49911     try {
49912       delete arg1;
49913     } catch (std::out_of_range& e) {
49914       {
49915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49916       };
49917     } catch (std::exception& e) {
49918       {
49919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (...) {
49922       {
49923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49924       };
49925     }
49926   }
49927 }
49928
49929
49930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49931   unsigned int jresult ;
49932   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49933   bool result;
49934
49935   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49936   {
49937     try {
49938       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);
49939     } catch (std::out_of_range& e) {
49940       {
49941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49942       };
49943     } catch (std::exception& e) {
49944       {
49945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49946       };
49947     } catch (...) {
49948       {
49949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49950       };
49951     }
49952   }
49953   jresult = result;
49954   return jresult;
49955 }
49956
49957
49958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49959   unsigned long jresult ;
49960   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49961   std::size_t result;
49962
49963   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49964   {
49965     try {
49966       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);
49967     } catch (std::out_of_range& e) {
49968       {
49969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49970       };
49971     } catch (std::exception& e) {
49972       {
49973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49974       };
49975     } catch (...) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49978       };
49979     }
49980   }
49981   jresult = (unsigned long)result;
49982   return jresult;
49983 }
49984
49985
49986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49987   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49988   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49989
49990   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49991   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49992   {
49993     try {
49994       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49995     } catch (std::out_of_range& e) {
49996       {
49997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49998       };
49999     } catch (std::exception& e) {
50000       {
50001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50002       };
50003     } catch (...) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50006       };
50007     }
50008   }
50009 }
50010
50011
50012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50013   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50014   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50015
50016   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50017   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50018   {
50019     try {
50020       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50021     } catch (std::out_of_range& e) {
50022       {
50023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50024       };
50025     } catch (std::exception& e) {
50026       {
50027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50028       };
50029     } catch (...) {
50030       {
50031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50032       };
50033     }
50034   }
50035 }
50036
50037
50038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50039   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50040   Dali::Actor arg2 ;
50041   Dali::LongPressGesture *arg3 = 0 ;
50042   Dali::Actor *argp2 ;
50043
50044   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50045   argp2 = (Dali::Actor *)jarg2;
50046   if (!argp2) {
50047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50048     return ;
50049   }
50050   arg2 = *argp2;
50051   arg3 = (Dali::LongPressGesture *)jarg3;
50052   if (!arg3) {
50053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50054     return ;
50055   }
50056   {
50057     try {
50058       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50059     } catch (std::out_of_range& e) {
50060       {
50061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50062       };
50063     } catch (std::exception& e) {
50064       {
50065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50066       };
50067     } catch (...) {
50068       {
50069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50070       };
50071     }
50072   }
50073 }
50074
50075
50076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50077   void * jresult ;
50078   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50079
50080   {
50081     try {
50082       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
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 = (void *)result;
50098   return jresult;
50099 }
50100
50101
50102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50103   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50104
50105   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50106   {
50107     try {
50108       delete arg1;
50109     } catch (std::out_of_range& e) {
50110       {
50111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50112       };
50113     } catch (std::exception& e) {
50114       {
50115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50116       };
50117     } catch (...) {
50118       {
50119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50120       };
50121     }
50122   }
50123 }
50124
50125
50126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50127   unsigned int jresult ;
50128   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50129   bool result;
50130
50131   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50132   {
50133     try {
50134       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);
50135     } catch (std::out_of_range& e) {
50136       {
50137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50138       };
50139     } catch (std::exception& e) {
50140       {
50141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50142       };
50143     } catch (...) {
50144       {
50145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50146       };
50147     }
50148   }
50149   jresult = result;
50150   return jresult;
50151 }
50152
50153
50154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50155   unsigned long jresult ;
50156   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50157   std::size_t result;
50158
50159   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50160   {
50161     try {
50162       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);
50163     } catch (std::out_of_range& e) {
50164       {
50165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50166       };
50167     } catch (std::exception& e) {
50168       {
50169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50170       };
50171     } catch (...) {
50172       {
50173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50174       };
50175     }
50176   }
50177   jresult = (unsigned long)result;
50178   return jresult;
50179 }
50180
50181
50182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50183   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50184   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50185
50186   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50187   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50188   {
50189     try {
50190       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50191     } catch (std::out_of_range& e) {
50192       {
50193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50194       };
50195     } catch (std::exception& e) {
50196       {
50197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50198       };
50199     } catch (...) {
50200       {
50201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50202       };
50203     }
50204   }
50205 }
50206
50207
50208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50209   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50210   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50211
50212   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50213   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50214   {
50215     try {
50216       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(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 unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50235   unsigned int jresult ;
50236   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50237   Dali::Actor arg2 ;
50238   Dali::TouchData *arg3 = 0 ;
50239   Dali::Actor *argp2 ;
50240   bool result;
50241
50242   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50243   argp2 = (Dali::Actor *)jarg2;
50244   if (!argp2) {
50245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50246     return 0;
50247   }
50248   arg2 = *argp2;
50249   arg3 = (Dali::TouchData *)jarg3;
50250   if (!arg3) {
50251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50252     return 0;
50253   }
50254   {
50255     try {
50256       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50257     } catch (std::out_of_range& e) {
50258       {
50259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50260       };
50261     } catch (std::exception& e) {
50262       {
50263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50264       };
50265     } catch (...) {
50266       {
50267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50268       };
50269     }
50270   }
50271   jresult = result;
50272   return jresult;
50273 }
50274
50275
50276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50277   void * jresult ;
50278   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50279
50280   {
50281     try {
50282       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
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 = (void *)result;
50298   return jresult;
50299 }
50300
50301
50302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50303   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50304
50305   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50306   {
50307     try {
50308       delete arg1;
50309     } catch (std::out_of_range& e) {
50310       {
50311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50312       };
50313     } catch (std::exception& e) {
50314       {
50315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50316       };
50317     } catch (...) {
50318       {
50319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50320       };
50321     }
50322   }
50323 }
50324
50325
50326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50327   unsigned int jresult ;
50328   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50329   bool result;
50330
50331   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50332   {
50333     try {
50334       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);
50335     } catch (std::out_of_range& e) {
50336       {
50337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50338       };
50339     } catch (std::exception& e) {
50340       {
50341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50342       };
50343     } catch (...) {
50344       {
50345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50346       };
50347     }
50348   }
50349   jresult = result;
50350   return jresult;
50351 }
50352
50353
50354 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50355   unsigned long jresult ;
50356   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50357   std::size_t result;
50358
50359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50360   {
50361     try {
50362       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);
50363     } catch (std::out_of_range& e) {
50364       {
50365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50366       };
50367     } catch (std::exception& e) {
50368       {
50369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (...) {
50372       {
50373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50374       };
50375     }
50376   }
50377   jresult = (unsigned long)result;
50378   return jresult;
50379 }
50380
50381
50382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50383   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50384   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50385
50386   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50387   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50388   {
50389     try {
50390       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50391     } catch (std::out_of_range& e) {
50392       {
50393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50394       };
50395     } catch (std::exception& e) {
50396       {
50397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50398       };
50399     } catch (...) {
50400       {
50401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50402       };
50403     }
50404   }
50405 }
50406
50407
50408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50409   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50410   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50411
50412   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50413   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50414   {
50415     try {
50416       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(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 unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50435   unsigned int jresult ;
50436   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50437   Dali::Actor arg2 ;
50438   Dali::HoverEvent *arg3 = 0 ;
50439   Dali::Actor *argp2 ;
50440   bool result;
50441
50442   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50443   argp2 = (Dali::Actor *)jarg2;
50444   if (!argp2) {
50445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50446     return 0;
50447   }
50448   arg2 = *argp2;
50449   arg3 = (Dali::HoverEvent *)jarg3;
50450   if (!arg3) {
50451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50452     return 0;
50453   }
50454   {
50455     try {
50456       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50457     } catch (std::out_of_range& e) {
50458       {
50459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50460       };
50461     } catch (std::exception& e) {
50462       {
50463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50464       };
50465     } catch (...) {
50466       {
50467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50468       };
50469     }
50470   }
50471   jresult = result;
50472   return jresult;
50473 }
50474
50475
50476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50477   void * jresult ;
50478   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50479
50480   {
50481     try {
50482       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
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 = (void *)result;
50498   return jresult;
50499 }
50500
50501
50502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50503   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50504
50505   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50506   {
50507     try {
50508       delete arg1;
50509     } catch (std::out_of_range& e) {
50510       {
50511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50512       };
50513     } catch (std::exception& e) {
50514       {
50515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50516       };
50517     } catch (...) {
50518       {
50519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50520       };
50521     }
50522   }
50523 }
50524
50525
50526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50527   unsigned int jresult ;
50528   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50529   bool result;
50530
50531   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50532   {
50533     try {
50534       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);
50535     } catch (std::out_of_range& e) {
50536       {
50537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50538       };
50539     } catch (std::exception& e) {
50540       {
50541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50546       };
50547     }
50548   }
50549   jresult = result;
50550   return jresult;
50551 }
50552
50553
50554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50555   unsigned long jresult ;
50556   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50557   std::size_t result;
50558
50559   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50560   {
50561     try {
50562       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);
50563     } catch (std::out_of_range& e) {
50564       {
50565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50566       };
50567     } catch (std::exception& e) {
50568       {
50569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50570       };
50571     } catch (...) {
50572       {
50573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50574       };
50575     }
50576   }
50577   jresult = (unsigned long)result;
50578   return jresult;
50579 }
50580
50581
50582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50583   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50584   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50585
50586   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50587   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50588   {
50589     try {
50590       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50591     } catch (std::out_of_range& e) {
50592       {
50593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50594       };
50595     } catch (std::exception& e) {
50596       {
50597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50598       };
50599     } catch (...) {
50600       {
50601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50602       };
50603     }
50604   }
50605 }
50606
50607
50608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50609   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50610   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50611
50612   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50613   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50614   {
50615     try {
50616       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(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 unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50635   unsigned int jresult ;
50636   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50637   Dali::Actor arg2 ;
50638   Dali::WheelEvent *arg3 = 0 ;
50639   Dali::Actor *argp2 ;
50640   bool result;
50641
50642   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50643   argp2 = (Dali::Actor *)jarg2;
50644   if (!argp2) {
50645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50646     return 0;
50647   }
50648   arg2 = *argp2;
50649   arg3 = (Dali::WheelEvent *)jarg3;
50650   if (!arg3) {
50651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50652     return 0;
50653   }
50654   {
50655     try {
50656       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50657     } catch (std::out_of_range& e) {
50658       {
50659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50660       };
50661     } catch (std::exception& e) {
50662       {
50663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50664       };
50665     } catch (...) {
50666       {
50667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50668       };
50669     }
50670   }
50671   jresult = result;
50672   return jresult;
50673 }
50674
50675
50676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50677   void * jresult ;
50678   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50679
50680   {
50681     try {
50682       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50683     } catch (std::out_of_range& e) {
50684       {
50685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50686       };
50687     } catch (std::exception& e) {
50688       {
50689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50690       };
50691     } catch (...) {
50692       {
50693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50694       };
50695     }
50696   }
50697   jresult = (void *)result;
50698   return jresult;
50699 }
50700
50701
50702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50703   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50704
50705   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50706   {
50707     try {
50708       delete arg1;
50709     } catch (std::out_of_range& e) {
50710       {
50711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50712       };
50713     } catch (std::exception& e) {
50714       {
50715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50716       };
50717     } catch (...) {
50718       {
50719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50720       };
50721     }
50722   }
50723 }
50724
50725
50726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50727   unsigned int jresult ;
50728   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50729   bool result;
50730
50731   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50732   {
50733     try {
50734       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50735     } catch (std::out_of_range& e) {
50736       {
50737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50738       };
50739     } catch (std::exception& e) {
50740       {
50741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50742       };
50743     } catch (...) {
50744       {
50745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50746       };
50747     }
50748   }
50749   jresult = result;
50750   return jresult;
50751 }
50752
50753
50754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50755   unsigned long jresult ;
50756   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50757   std::size_t result;
50758
50759   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50760   {
50761     try {
50762       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50763     } catch (std::out_of_range& e) {
50764       {
50765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50766       };
50767     } catch (std::exception& e) {
50768       {
50769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (...) {
50772       {
50773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50774       };
50775     }
50776   }
50777   jresult = (unsigned long)result;
50778   return jresult;
50779 }
50780
50781
50782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50783   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50784   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50785
50786   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50787   arg2 = (void (*)(Dali::Actor))jarg2;
50788   {
50789     try {
50790       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50791     } catch (std::out_of_range& e) {
50792       {
50793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50794       };
50795     } catch (std::exception& e) {
50796       {
50797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50798       };
50799     } catch (...) {
50800       {
50801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50802       };
50803     }
50804   }
50805 }
50806
50807
50808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50809   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50810   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50811
50812   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50813   arg2 = (void (*)(Dali::Actor))jarg2;
50814   {
50815     try {
50816       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50817     } catch (std::out_of_range& e) {
50818       {
50819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50820       };
50821     } catch (std::exception& e) {
50822       {
50823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50824       };
50825     } catch (...) {
50826       {
50827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50828       };
50829     }
50830   }
50831 }
50832
50833
50834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50835   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50836   Dali::Actor arg2 ;
50837   Dali::Actor *argp2 ;
50838
50839   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50840   argp2 = (Dali::Actor *)jarg2;
50841   if (!argp2) {
50842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50843     return ;
50844   }
50845   arg2 = *argp2;
50846   {
50847     try {
50848       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50849     } catch (std::out_of_range& e) {
50850       {
50851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50852       };
50853     } catch (std::exception& e) {
50854       {
50855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50856       };
50857     } catch (...) {
50858       {
50859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50860       };
50861     }
50862   }
50863 }
50864
50865
50866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50867   void * jresult ;
50868   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50869
50870   {
50871     try {
50872       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50873     } catch (std::out_of_range& e) {
50874       {
50875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50876       };
50877     } catch (std::exception& e) {
50878       {
50879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50880       };
50881     } catch (...) {
50882       {
50883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50884       };
50885     }
50886   }
50887   jresult = (void *)result;
50888   return jresult;
50889 }
50890
50891
50892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50893   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50894
50895   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50896   {
50897     try {
50898       delete arg1;
50899     } catch (std::out_of_range& e) {
50900       {
50901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50902       };
50903     } catch (std::exception& e) {
50904       {
50905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50906       };
50907     } catch (...) {
50908       {
50909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50910       };
50911     }
50912   }
50913 }
50914
50915
50916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50917   unsigned int jresult ;
50918   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50919   bool result;
50920
50921   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50922   {
50923     try {
50924       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50925     } catch (std::out_of_range& e) {
50926       {
50927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50928       };
50929     } catch (std::exception& e) {
50930       {
50931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50932       };
50933     } catch (...) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50936       };
50937     }
50938   }
50939   jresult = result;
50940   return jresult;
50941 }
50942
50943
50944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50945   unsigned long jresult ;
50946   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50947   std::size_t result;
50948
50949   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50950   {
50951     try {
50952       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50953     } catch (std::out_of_range& e) {
50954       {
50955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50956       };
50957     } catch (std::exception& e) {
50958       {
50959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50960       };
50961     } catch (...) {
50962       {
50963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50964       };
50965     }
50966   }
50967   jresult = (unsigned long)result;
50968   return jresult;
50969 }
50970
50971
50972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50973   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50974   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50975
50976   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50977   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50978   {
50979     try {
50980       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50981     } catch (std::out_of_range& e) {
50982       {
50983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50984       };
50985     } catch (std::exception& e) {
50986       {
50987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50988       };
50989     } catch (...) {
50990       {
50991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50992       };
50993     }
50994   }
50995 }
50996
50997
50998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50999   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51000   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51001
51002   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51003   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51004   {
51005     try {
51006       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51007     } catch (std::out_of_range& e) {
51008       {
51009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51010       };
51011     } catch (std::exception& e) {
51012       {
51013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51014       };
51015     } catch (...) {
51016       {
51017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51018       };
51019     }
51020   }
51021 }
51022
51023
51024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51025   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51026   Dali::KeyEvent *arg2 = 0 ;
51027
51028   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51029   arg2 = (Dali::KeyEvent *)jarg2;
51030   if (!arg2) {
51031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51032     return ;
51033   }
51034   {
51035     try {
51036       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51044       };
51045     } catch (...) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51048       };
51049     }
51050   }
51051 }
51052
51053
51054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51055   void * jresult ;
51056   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51057
51058   {
51059     try {
51060       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51061     } catch (std::out_of_range& e) {
51062       {
51063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51064       };
51065     } catch (std::exception& e) {
51066       {
51067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51068       };
51069     } catch (...) {
51070       {
51071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51072       };
51073     }
51074   }
51075   jresult = (void *)result;
51076   return jresult;
51077 }
51078
51079
51080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51081   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51082
51083   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51084   {
51085     try {
51086       delete arg1;
51087     } catch (std::out_of_range& e) {
51088       {
51089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51090       };
51091     } catch (std::exception& e) {
51092       {
51093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51094       };
51095     } catch (...) {
51096       {
51097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51098       };
51099     }
51100   }
51101 }
51102
51103
51104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51105   unsigned int jresult ;
51106   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51107   bool result;
51108
51109   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51110   {
51111     try {
51112       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51113     } catch (std::out_of_range& e) {
51114       {
51115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51116       };
51117     } catch (std::exception& e) {
51118       {
51119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51120       };
51121     } catch (...) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51124       };
51125     }
51126   }
51127   jresult = result;
51128   return jresult;
51129 }
51130
51131
51132 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51133   unsigned long jresult ;
51134   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51135   std::size_t result;
51136
51137   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51138   {
51139     try {
51140       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51141     } catch (std::out_of_range& e) {
51142       {
51143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51144       };
51145     } catch (std::exception& e) {
51146       {
51147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (...) {
51150       {
51151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51152       };
51153     }
51154   }
51155   jresult = (unsigned long)result;
51156   return jresult;
51157 }
51158
51159
51160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51161   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51162   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51163
51164   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51165   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51166   {
51167     try {
51168       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51169     } catch (std::out_of_range& e) {
51170       {
51171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51172       };
51173     } catch (std::exception& e) {
51174       {
51175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51176       };
51177     } catch (...) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51180       };
51181     }
51182   }
51183 }
51184
51185
51186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51187   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51188   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51189
51190   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51191   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51192   {
51193     try {
51194       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51195     } catch (std::out_of_range& e) {
51196       {
51197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51198       };
51199     } catch (std::exception& e) {
51200       {
51201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51202       };
51203     } catch (...) {
51204       {
51205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51206       };
51207     }
51208   }
51209 }
51210
51211
51212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51213   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51214   Dali::TouchData *arg2 = 0 ;
51215
51216   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51217   arg2 = (Dali::TouchData *)jarg2;
51218   if (!arg2) {
51219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51220     return ;
51221   }
51222   {
51223     try {
51224       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51225     } catch (std::out_of_range& e) {
51226       {
51227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51228       };
51229     } catch (std::exception& e) {
51230       {
51231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51232       };
51233     } catch (...) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51236       };
51237     }
51238   }
51239 }
51240
51241
51242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51243   void * jresult ;
51244   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51245
51246   {
51247     try {
51248       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51249     } catch (std::out_of_range& e) {
51250       {
51251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51252       };
51253     } catch (std::exception& e) {
51254       {
51255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51256       };
51257     } catch (...) {
51258       {
51259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51260       };
51261     }
51262   }
51263   jresult = (void *)result;
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51269   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51270
51271   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51272   {
51273     try {
51274       delete arg1;
51275     } catch (std::out_of_range& e) {
51276       {
51277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51278       };
51279     } catch (std::exception& e) {
51280       {
51281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (...) {
51284       {
51285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51286       };
51287     }
51288   }
51289 }
51290
51291
51292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51293   unsigned int jresult ;
51294   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51295   bool result;
51296
51297   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51298   {
51299     try {
51300       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51301     } catch (std::out_of_range& e) {
51302       {
51303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51304       };
51305     } catch (std::exception& e) {
51306       {
51307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51308       };
51309     } catch (...) {
51310       {
51311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51312       };
51313     }
51314   }
51315   jresult = result;
51316   return jresult;
51317 }
51318
51319
51320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51321   unsigned long jresult ;
51322   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51323   std::size_t result;
51324
51325   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51326   {
51327     try {
51328       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51329     } catch (std::out_of_range& e) {
51330       {
51331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51332       };
51333     } catch (std::exception& e) {
51334       {
51335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (...) {
51338       {
51339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51340       };
51341     }
51342   }
51343   jresult = (unsigned long)result;
51344   return jresult;
51345 }
51346
51347
51348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51349   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51350   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51351
51352   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51353   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51354   {
51355     try {
51356       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51357     } catch (std::out_of_range& e) {
51358       {
51359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51360       };
51361     } catch (std::exception& e) {
51362       {
51363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51364       };
51365     } catch (...) {
51366       {
51367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51368       };
51369     }
51370   }
51371 }
51372
51373
51374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51375   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51376   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51377
51378   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51379   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51380   {
51381     try {
51382       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51383     } catch (std::out_of_range& e) {
51384       {
51385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51386       };
51387     } catch (std::exception& e) {
51388       {
51389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51390       };
51391     } catch (...) {
51392       {
51393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51394       };
51395     }
51396   }
51397 }
51398
51399
51400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51401   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51402   Dali::WheelEvent *arg2 = 0 ;
51403
51404   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51405   arg2 = (Dali::WheelEvent *)jarg2;
51406   if (!arg2) {
51407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51408     return ;
51409   }
51410   {
51411     try {
51412       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51413     } catch (std::out_of_range& e) {
51414       {
51415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51416       };
51417     } catch (std::exception& e) {
51418       {
51419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51424       };
51425     }
51426   }
51427 }
51428
51429
51430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51431   void * jresult ;
51432   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51433
51434   {
51435     try {
51436       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51437     } catch (std::out_of_range& e) {
51438       {
51439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51440       };
51441     } catch (std::exception& e) {
51442       {
51443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51444       };
51445     } catch (...) {
51446       {
51447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51448       };
51449     }
51450   }
51451   jresult = (void *)result;
51452   return jresult;
51453 }
51454
51455
51456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51457   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51458
51459   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51460   {
51461     try {
51462       delete arg1;
51463     } catch (std::out_of_range& e) {
51464       {
51465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51466       };
51467     } catch (std::exception& e) {
51468       {
51469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (...) {
51472       {
51473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51474       };
51475     }
51476   }
51477 }
51478
51479
51480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51481   void * jresult ;
51482   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51483
51484   {
51485     try {
51486       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51487     } catch (std::out_of_range& e) {
51488       {
51489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51490       };
51491     } catch (std::exception& e) {
51492       {
51493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51494       };
51495     } catch (...) {
51496       {
51497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51498       };
51499     }
51500   }
51501   jresult = (void *)result;
51502   return jresult;
51503 }
51504
51505
51506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51507   void * jresult ;
51508   Dali::Radian arg1 ;
51509   Dali::Radian arg2 ;
51510   Dali::Radian *argp1 ;
51511   Dali::Radian *argp2 ;
51512   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51513
51514   argp1 = (Dali::Radian *)jarg1;
51515   if (!argp1) {
51516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51517     return 0;
51518   }
51519   arg1 = *argp1;
51520   argp2 = (Dali::Radian *)jarg2;
51521   if (!argp2) {
51522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51523     return 0;
51524   }
51525   arg2 = *argp2;
51526   {
51527     try {
51528       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51529     } catch (std::out_of_range& e) {
51530       {
51531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51532       };
51533     } catch (std::exception& e) {
51534       {
51535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51536       };
51537     } catch (...) {
51538       {
51539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51540       };
51541     }
51542   }
51543   jresult = (void *)result;
51544   return jresult;
51545 }
51546
51547
51548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51549   void * jresult ;
51550   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51551   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51552
51553   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51554   if (!arg1) {
51555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51556     return 0;
51557   }
51558   {
51559     try {
51560       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51561     } catch (std::out_of_range& e) {
51562       {
51563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51564       };
51565     } catch (std::exception& e) {
51566       {
51567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51568       };
51569     } catch (...) {
51570       {
51571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51572       };
51573     }
51574   }
51575   jresult = (void *)result;
51576   return jresult;
51577 }
51578
51579
51580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51581   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51582   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51583
51584   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51585   arg2 = (Dali::Radian *)jarg2;
51586   if (arg1) (arg1)->first = *arg2;
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51591   void * jresult ;
51592   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51593   Dali::Radian *result = 0 ;
51594
51595   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51596   result = (Dali::Radian *)& ((arg1)->first);
51597   jresult = (void *)result;
51598   return jresult;
51599 }
51600
51601
51602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51603   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51604   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51605
51606   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51607   arg2 = (Dali::Radian *)jarg2;
51608   if (arg1) (arg1)->second = *arg2;
51609 }
51610
51611
51612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51613   void * jresult ;
51614   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51615   Dali::Radian *result = 0 ;
51616
51617   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51618   result = (Dali::Radian *)& ((arg1)->second);
51619   jresult = (void *)result;
51620   return jresult;
51621 }
51622
51623
51624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51625   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51626
51627   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51628   {
51629     try {
51630       delete arg1;
51631     } catch (std::out_of_range& e) {
51632       {
51633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51634       };
51635     } catch (std::exception& e) {
51636       {
51637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51638       };
51639     } catch (...) {
51640       {
51641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51642       };
51643     }
51644   }
51645 }
51646
51647
51648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51649   unsigned int jresult ;
51650   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51651   bool result;
51652
51653   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51654   {
51655     try {
51656       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);
51657     } catch (std::out_of_range& e) {
51658       {
51659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51660       };
51661     } catch (std::exception& e) {
51662       {
51663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51664       };
51665     } catch (...) {
51666       {
51667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51668       };
51669     }
51670   }
51671   jresult = result;
51672   return jresult;
51673 }
51674
51675
51676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51677   unsigned long jresult ;
51678   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51679   std::size_t result;
51680
51681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51682   {
51683     try {
51684       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);
51685     } catch (std::out_of_range& e) {
51686       {
51687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51688       };
51689     } catch (std::exception& e) {
51690       {
51691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51692       };
51693     } catch (...) {
51694       {
51695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51696       };
51697     }
51698   }
51699   jresult = (unsigned long)result;
51700   return jresult;
51701 }
51702
51703
51704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51705   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51706   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51707
51708   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51709   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51710   {
51711     try {
51712       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51713     } catch (std::out_of_range& e) {
51714       {
51715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51716       };
51717     } catch (std::exception& e) {
51718       {
51719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51720       };
51721     } catch (...) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51724       };
51725     }
51726   }
51727 }
51728
51729
51730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51731   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51732   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51733
51734   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51735   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51736   {
51737     try {
51738       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51739     } catch (std::out_of_range& e) {
51740       {
51741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51742       };
51743     } catch (std::exception& e) {
51744       {
51745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51746       };
51747     } catch (...) {
51748       {
51749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51750       };
51751     }
51752   }
51753 }
51754
51755
51756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51757   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51758   Dali::Actor arg2 ;
51759   Dali::PanGesture *arg3 = 0 ;
51760   Dali::Actor *argp2 ;
51761
51762   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51763   argp2 = (Dali::Actor *)jarg2;
51764   if (!argp2) {
51765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51766     return ;
51767   }
51768   arg2 = *argp2;
51769   arg3 = (Dali::PanGesture *)jarg3;
51770   if (!arg3) {
51771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51772     return ;
51773   }
51774   {
51775     try {
51776       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51777     } catch (std::out_of_range& e) {
51778       {
51779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51780       };
51781     } catch (std::exception& e) {
51782       {
51783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51784       };
51785     } catch (...) {
51786       {
51787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51788       };
51789     }
51790   }
51791 }
51792
51793
51794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51795   void * jresult ;
51796   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51797
51798   {
51799     try {
51800       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51801     } catch (std::out_of_range& e) {
51802       {
51803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51804       };
51805     } catch (std::exception& e) {
51806       {
51807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51808       };
51809     } catch (...) {
51810       {
51811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51812       };
51813     }
51814   }
51815   jresult = (void *)result;
51816   return jresult;
51817 }
51818
51819
51820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51821   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51822
51823   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51824   {
51825     try {
51826       delete arg1;
51827     } catch (std::out_of_range& e) {
51828       {
51829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51830       };
51831     } catch (std::exception& e) {
51832       {
51833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51834       };
51835     } catch (...) {
51836       {
51837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51838       };
51839     }
51840   }
51841 }
51842
51843
51844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51845   unsigned int jresult ;
51846   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51847   bool result;
51848
51849   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51850   {
51851     try {
51852       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);
51853     } catch (std::out_of_range& e) {
51854       {
51855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (std::exception& e) {
51858       {
51859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (...) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51864       };
51865     }
51866   }
51867   jresult = result;
51868   return jresult;
51869 }
51870
51871
51872 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51873   unsigned long jresult ;
51874   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51875   std::size_t result;
51876
51877   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51878   {
51879     try {
51880       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);
51881     } catch (std::out_of_range& e) {
51882       {
51883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51884       };
51885     } catch (std::exception& e) {
51886       {
51887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (...) {
51890       {
51891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51892       };
51893     }
51894   }
51895   jresult = (unsigned long)result;
51896   return jresult;
51897 }
51898
51899
51900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51901   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51902   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51903
51904   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51905   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51906   {
51907     try {
51908       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51909     } catch (std::out_of_range& e) {
51910       {
51911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51912       };
51913     } catch (std::exception& e) {
51914       {
51915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51916       };
51917     } catch (...) {
51918       {
51919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51920       };
51921     }
51922   }
51923 }
51924
51925
51926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51927   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51928   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51929
51930   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51931   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51932   {
51933     try {
51934       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51935     } catch (std::out_of_range& e) {
51936       {
51937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51938       };
51939     } catch (std::exception& e) {
51940       {
51941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51942       };
51943     } catch (...) {
51944       {
51945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51946       };
51947     }
51948   }
51949 }
51950
51951
51952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51953   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51954   Dali::Actor arg2 ;
51955   Dali::PinchGesture *arg3 = 0 ;
51956   Dali::Actor *argp2 ;
51957
51958   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51959   argp2 = (Dali::Actor *)jarg2;
51960   if (!argp2) {
51961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51962     return ;
51963   }
51964   arg2 = *argp2;
51965   arg3 = (Dali::PinchGesture *)jarg3;
51966   if (!arg3) {
51967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51968     return ;
51969   }
51970   {
51971     try {
51972       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51973     } catch (std::out_of_range& e) {
51974       {
51975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51976       };
51977     } catch (std::exception& e) {
51978       {
51979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51980       };
51981     } catch (...) {
51982       {
51983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51984       };
51985     }
51986   }
51987 }
51988
51989
51990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51991   void * jresult ;
51992   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51993
51994   {
51995     try {
51996       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51997     } catch (std::out_of_range& e) {
51998       {
51999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52000       };
52001     } catch (std::exception& e) {
52002       {
52003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52004       };
52005     } catch (...) {
52006       {
52007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52008       };
52009     }
52010   }
52011   jresult = (void *)result;
52012   return jresult;
52013 }
52014
52015
52016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52017   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52018
52019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52020   {
52021     try {
52022       delete arg1;
52023     } catch (std::out_of_range& e) {
52024       {
52025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (std::exception& e) {
52028       {
52029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52030       };
52031     } catch (...) {
52032       {
52033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52034       };
52035     }
52036   }
52037 }
52038
52039
52040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52041   unsigned int jresult ;
52042   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52043   bool result;
52044
52045   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52046   {
52047     try {
52048       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);
52049     } catch (std::out_of_range& e) {
52050       {
52051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52052       };
52053     } catch (std::exception& e) {
52054       {
52055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52056       };
52057     } catch (...) {
52058       {
52059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52060       };
52061     }
52062   }
52063   jresult = result;
52064   return jresult;
52065 }
52066
52067
52068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52069   unsigned long jresult ;
52070   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52071   std::size_t result;
52072
52073   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52074   {
52075     try {
52076       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);
52077     } catch (std::out_of_range& e) {
52078       {
52079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52080       };
52081     } catch (std::exception& e) {
52082       {
52083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (...) {
52086       {
52087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52088       };
52089     }
52090   }
52091   jresult = (unsigned long)result;
52092   return jresult;
52093 }
52094
52095
52096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52097   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52098   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52099
52100   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52101   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52102   {
52103     try {
52104       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52105     } catch (std::out_of_range& e) {
52106       {
52107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52108       };
52109     } catch (std::exception& e) {
52110       {
52111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52112       };
52113     } catch (...) {
52114       {
52115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52116       };
52117     }
52118   }
52119 }
52120
52121
52122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52123   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52124   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52125
52126   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52127   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52128   {
52129     try {
52130       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52131     } catch (std::out_of_range& e) {
52132       {
52133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52134       };
52135     } catch (std::exception& e) {
52136       {
52137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52138       };
52139     } catch (...) {
52140       {
52141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52142       };
52143     }
52144   }
52145 }
52146
52147
52148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52149   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52150   Dali::Actor arg2 ;
52151   Dali::TapGesture *arg3 = 0 ;
52152   Dali::Actor *argp2 ;
52153
52154   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52155   argp2 = (Dali::Actor *)jarg2;
52156   if (!argp2) {
52157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52158     return ;
52159   }
52160   arg2 = *argp2;
52161   arg3 = (Dali::TapGesture *)jarg3;
52162   if (!arg3) {
52163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52164     return ;
52165   }
52166   {
52167     try {
52168       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52169     } catch (std::out_of_range& e) {
52170       {
52171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52172       };
52173     } catch (std::exception& e) {
52174       {
52175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52176       };
52177     } catch (...) {
52178       {
52179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52180       };
52181     }
52182   }
52183 }
52184
52185
52186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52187   void * jresult ;
52188   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52189
52190   {
52191     try {
52192       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52193     } catch (std::out_of_range& e) {
52194       {
52195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52196       };
52197     } catch (std::exception& e) {
52198       {
52199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52200       };
52201     } catch (...) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52204       };
52205     }
52206   }
52207   jresult = (void *)result;
52208   return jresult;
52209 }
52210
52211
52212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52213   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52214
52215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52216   {
52217     try {
52218       delete arg1;
52219     } catch (std::out_of_range& e) {
52220       {
52221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (std::exception& e) {
52224       {
52225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52230       };
52231     }
52232   }
52233 }
52234
52235
52236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52237   unsigned int jresult ;
52238   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52239   bool result;
52240
52241   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52242   {
52243     try {
52244       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52245     } catch (std::out_of_range& e) {
52246       {
52247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52248       };
52249     } catch (std::exception& e) {
52250       {
52251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52252       };
52253     } catch (...) {
52254       {
52255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52256       };
52257     }
52258   }
52259   jresult = result;
52260   return jresult;
52261 }
52262
52263
52264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52265   unsigned long jresult ;
52266   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52267   std::size_t result;
52268
52269   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52270   {
52271     try {
52272       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52273     } catch (std::out_of_range& e) {
52274       {
52275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52276       };
52277     } catch (std::exception& e) {
52278       {
52279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52280       };
52281     } catch (...) {
52282       {
52283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52284       };
52285     }
52286   }
52287   jresult = (unsigned long)result;
52288   return jresult;
52289 }
52290
52291
52292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52293   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52294   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52295
52296   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52297   arg2 = (void (*)(Dali::Animation &))jarg2;
52298   {
52299     try {
52300       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52301     } catch (std::out_of_range& e) {
52302       {
52303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52304       };
52305     } catch (std::exception& e) {
52306       {
52307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52308       };
52309     } catch (...) {
52310       {
52311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52312       };
52313     }
52314   }
52315 }
52316
52317
52318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52319   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52320   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52321
52322   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52323   arg2 = (void (*)(Dali::Animation &))jarg2;
52324   {
52325     try {
52326       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52327     } catch (std::out_of_range& e) {
52328       {
52329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52330       };
52331     } catch (std::exception& e) {
52332       {
52333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52334       };
52335     } catch (...) {
52336       {
52337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52338       };
52339     }
52340   }
52341 }
52342
52343
52344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52345   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52346   Dali::Animation *arg2 = 0 ;
52347
52348   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52349   arg2 = (Dali::Animation *)jarg2;
52350   if (!arg2) {
52351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52352     return ;
52353   }
52354   {
52355     try {
52356       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52364       };
52365     } catch (...) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52368       };
52369     }
52370   }
52371 }
52372
52373
52374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52375   void * jresult ;
52376   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52377
52378   {
52379     try {
52380       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52381     } catch (std::out_of_range& e) {
52382       {
52383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52384       };
52385     } catch (std::exception& e) {
52386       {
52387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52388       };
52389     } catch (...) {
52390       {
52391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52392       };
52393     }
52394   }
52395   jresult = (void *)result;
52396   return jresult;
52397 }
52398
52399
52400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52401   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52402
52403   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52404   {
52405     try {
52406       delete arg1;
52407     } catch (std::out_of_range& e) {
52408       {
52409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52410       };
52411     } catch (std::exception& e) {
52412       {
52413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52414       };
52415     } catch (...) {
52416       {
52417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52418       };
52419     }
52420   }
52421 }
52422
52423
52424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52425   unsigned int jresult ;
52426   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52427   bool result;
52428
52429   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52430   {
52431     try {
52432       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52433     } catch (std::out_of_range& e) {
52434       {
52435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52436       };
52437     } catch (std::exception& e) {
52438       {
52439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52440       };
52441     } catch (...) {
52442       {
52443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52444       };
52445     }
52446   }
52447   jresult = result;
52448   return jresult;
52449 }
52450
52451
52452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52453   unsigned long jresult ;
52454   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52455   std::size_t result;
52456
52457   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52458   {
52459     try {
52460       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52461     } catch (std::out_of_range& e) {
52462       {
52463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52464       };
52465     } catch (std::exception& e) {
52466       {
52467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52468       };
52469     } catch (...) {
52470       {
52471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52472       };
52473     }
52474   }
52475   jresult = (unsigned long)result;
52476   return jresult;
52477 }
52478
52479
52480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52481   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52482   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52483
52484   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52485   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52486   {
52487     try {
52488       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52489     } catch (std::out_of_range& e) {
52490       {
52491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52492       };
52493     } catch (std::exception& e) {
52494       {
52495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52496       };
52497     } catch (...) {
52498       {
52499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52500       };
52501     }
52502   }
52503 }
52504
52505
52506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52507   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52508   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52509
52510   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52511   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52512   {
52513     try {
52514       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52515     } catch (std::out_of_range& e) {
52516       {
52517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52518       };
52519     } catch (std::exception& e) {
52520       {
52521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52522       };
52523     } catch (...) {
52524       {
52525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52526       };
52527     }
52528   }
52529 }
52530
52531
52532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52533   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52534   Dali::ResourceImage arg2 ;
52535   Dali::ResourceImage *argp2 ;
52536
52537   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52538   argp2 = (Dali::ResourceImage *)jarg2;
52539   if (!argp2) {
52540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52541     return ;
52542   }
52543   arg2 = *argp2;
52544   {
52545     try {
52546       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52547     } catch (std::out_of_range& e) {
52548       {
52549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52550       };
52551     } catch (std::exception& e) {
52552       {
52553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52554       };
52555     } catch (...) {
52556       {
52557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52558       };
52559     }
52560   }
52561 }
52562
52563
52564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52565   void * jresult ;
52566   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52567
52568   {
52569     try {
52570       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52571     } catch (std::out_of_range& e) {
52572       {
52573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52574       };
52575     } catch (std::exception& e) {
52576       {
52577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52578       };
52579     } catch (...) {
52580       {
52581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52582       };
52583     }
52584   }
52585   jresult = (void *)result;
52586   return jresult;
52587 }
52588
52589
52590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52591   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52592
52593   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52594   {
52595     try {
52596       delete arg1;
52597     } catch (std::out_of_range& e) {
52598       {
52599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52600       };
52601     } catch (std::exception& e) {
52602       {
52603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (...) {
52606       {
52607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52608       };
52609     }
52610   }
52611 }
52612
52613
52614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52615   unsigned int jresult ;
52616   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52617   bool result;
52618
52619   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52620   {
52621     try {
52622       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52623     } catch (std::out_of_range& e) {
52624       {
52625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52626       };
52627     } catch (std::exception& e) {
52628       {
52629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (...) {
52632       {
52633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52634       };
52635     }
52636   }
52637   jresult = result;
52638   return jresult;
52639 }
52640
52641
52642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52643   unsigned long jresult ;
52644   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52645   std::size_t result;
52646
52647   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52648   {
52649     try {
52650       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52651     } catch (std::out_of_range& e) {
52652       {
52653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52654       };
52655     } catch (std::exception& e) {
52656       {
52657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52658       };
52659     } catch (...) {
52660       {
52661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52662       };
52663     }
52664   }
52665   jresult = (unsigned long)result;
52666   return jresult;
52667 }
52668
52669
52670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52671   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52672   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52673
52674   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52675   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52676   {
52677     try {
52678       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52679     } catch (std::out_of_range& e) {
52680       {
52681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52682       };
52683     } catch (std::exception& e) {
52684       {
52685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52690       };
52691     }
52692   }
52693 }
52694
52695
52696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52697   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52698   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52699
52700   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52701   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52702   {
52703     try {
52704       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52712       };
52713     } catch (...) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52716       };
52717     }
52718   }
52719 }
52720
52721
52722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52723   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52724   Dali::Actor arg2 ;
52725   bool arg3 ;
52726   Dali::DevelActor::VisibilityChange::Type arg4 ;
52727   Dali::Actor *argp2 ;
52728
52729   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52730   argp2 = (Dali::Actor *)jarg2;
52731   if (!argp2) {
52732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52733     return ;
52734   }
52735   arg2 = *argp2;
52736   arg3 = jarg3 ? true : false;
52737   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52738   {
52739     try {
52740       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52741     } catch (std::out_of_range& e) {
52742       {
52743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52744       };
52745     } catch (std::exception& e) {
52746       {
52747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52748       };
52749     } catch (...) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52752       };
52753     }
52754   }
52755 }
52756
52757
52758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52759   void * jresult ;
52760   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52761
52762   {
52763     try {
52764       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52765     } catch (std::out_of_range& e) {
52766       {
52767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52768       };
52769     } catch (std::exception& e) {
52770       {
52771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52772       };
52773     } catch (...) {
52774       {
52775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52776       };
52777     }
52778   }
52779   jresult = (void *)result;
52780   return jresult;
52781 }
52782
52783
52784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52785   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52786
52787   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52788   {
52789     try {
52790       delete arg1;
52791     } catch (std::out_of_range& e) {
52792       {
52793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52794       };
52795     } catch (std::exception& e) {
52796       {
52797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52798       };
52799     } catch (...) {
52800       {
52801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52802       };
52803     }
52804   }
52805 }
52806
52807
52808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52809   void * jresult ;
52810   Dali::Timer *result = 0 ;
52811
52812   {
52813     try {
52814       result = (Dali::Timer *)new Dali::Timer();
52815     } catch (std::out_of_range& e) {
52816       {
52817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52818       };
52819     } catch (std::exception& e) {
52820       {
52821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52822       };
52823     } catch (...) {
52824       {
52825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52826       };
52827     }
52828   }
52829   jresult = (void *)result;
52830   return jresult;
52831 }
52832
52833
52834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52835   void * jresult ;
52836   unsigned int arg1 ;
52837   Dali::Timer result;
52838
52839   arg1 = (unsigned int)jarg1;
52840   {
52841     try {
52842       result = Dali::Timer::New(arg1);
52843     } catch (std::out_of_range& e) {
52844       {
52845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52846       };
52847     } catch (std::exception& e) {
52848       {
52849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52850       };
52851     } catch (...) {
52852       {
52853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52854       };
52855     }
52856   }
52857   jresult = new Dali::Timer((const Dali::Timer &)result);
52858   return jresult;
52859 }
52860
52861
52862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52863   void * jresult ;
52864   Dali::Timer *arg1 = 0 ;
52865   Dali::Timer *result = 0 ;
52866
52867   arg1 = (Dali::Timer *)jarg1;
52868   if (!arg1) {
52869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52870     return 0;
52871   }
52872   {
52873     try {
52874       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52875     } catch (std::out_of_range& e) {
52876       {
52877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52878       };
52879     } catch (std::exception& e) {
52880       {
52881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52882       };
52883     } catch (...) {
52884       {
52885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52886       };
52887     }
52888   }
52889   jresult = (void *)result;
52890   return jresult;
52891 }
52892
52893
52894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52895   void * jresult ;
52896   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52897   Dali::Timer *arg2 = 0 ;
52898   Dali::Timer *result = 0 ;
52899
52900   arg1 = (Dali::Timer *)jarg1;
52901   arg2 = (Dali::Timer *)jarg2;
52902   if (!arg2) {
52903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52904     return 0;
52905   }
52906   {
52907     try {
52908       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52909     } catch (std::out_of_range& e) {
52910       {
52911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52912       };
52913     } catch (std::exception& e) {
52914       {
52915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52916       };
52917     } catch (...) {
52918       {
52919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52920       };
52921     }
52922   }
52923   jresult = (void *)result;
52924   return jresult;
52925 }
52926
52927
52928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52929   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52930
52931   arg1 = (Dali::Timer *)jarg1;
52932   {
52933     try {
52934       delete arg1;
52935     } catch (std::out_of_range& e) {
52936       {
52937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52938       };
52939     } catch (std::exception& e) {
52940       {
52941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (...) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52946       };
52947     }
52948   }
52949 }
52950
52951
52952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52953   void * jresult ;
52954   Dali::BaseHandle arg1 ;
52955   Dali::BaseHandle *argp1 ;
52956   Dali::Timer result;
52957
52958   argp1 = (Dali::BaseHandle *)jarg1;
52959   if (!argp1) {
52960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52961     return 0;
52962   }
52963   arg1 = *argp1;
52964   {
52965     try {
52966       result = Dali::Timer::DownCast(arg1);
52967     } catch (std::out_of_range& e) {
52968       {
52969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52970       };
52971     } catch (std::exception& e) {
52972       {
52973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (...) {
52976       {
52977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52978       };
52979     }
52980   }
52981   jresult = new Dali::Timer((const Dali::Timer &)result);
52982   return jresult;
52983 }
52984
52985
52986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52987   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52988
52989   arg1 = (Dali::Timer *)jarg1;
52990   {
52991     try {
52992       (arg1)->Start();
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53004       };
53005     }
53006   }
53007 }
53008
53009
53010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53011   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53012
53013   arg1 = (Dali::Timer *)jarg1;
53014   {
53015     try {
53016       (arg1)->Stop();
53017     } catch (std::out_of_range& e) {
53018       {
53019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53020       };
53021     } catch (std::exception& e) {
53022       {
53023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53024       };
53025     } catch (...) {
53026       {
53027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53028       };
53029     }
53030   }
53031 }
53032
53033
53034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53035   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53036   unsigned int arg2 ;
53037
53038   arg1 = (Dali::Timer *)jarg1;
53039   arg2 = (unsigned int)jarg2;
53040   {
53041     try {
53042       (arg1)->SetInterval(arg2);
53043     } catch (std::out_of_range& e) {
53044       {
53045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53046       };
53047     } catch (std::exception& e) {
53048       {
53049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (...) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53054       };
53055     }
53056   }
53057 }
53058
53059
53060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53061   unsigned int jresult ;
53062   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53063   unsigned int result;
53064
53065   arg1 = (Dali::Timer *)jarg1;
53066   {
53067     try {
53068       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53069     } catch (std::out_of_range& e) {
53070       {
53071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53072       };
53073     } catch (std::exception& e) {
53074       {
53075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53076       };
53077     } catch (...) {
53078       {
53079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53080       };
53081     }
53082   }
53083   jresult = result;
53084   return jresult;
53085 }
53086
53087
53088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53089   unsigned int jresult ;
53090   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53091   bool result;
53092
53093   arg1 = (Dali::Timer *)jarg1;
53094   {
53095     try {
53096       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53097     } catch (std::out_of_range& e) {
53098       {
53099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53100       };
53101     } catch (std::exception& e) {
53102       {
53103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53104       };
53105     } catch (...) {
53106       {
53107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53108       };
53109     }
53110   }
53111   jresult = result;
53112   return jresult;
53113 }
53114
53115
53116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53117   void * jresult ;
53118   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53119   Dali::Timer::TimerSignalType *result = 0 ;
53120
53121   arg1 = (Dali::Timer *)jarg1;
53122   {
53123     try {
53124       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53125     } catch (std::out_of_range& e) {
53126       {
53127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53128       };
53129     } catch (std::exception& e) {
53130       {
53131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53132       };
53133     } catch (...) {
53134       {
53135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53136       };
53137     }
53138   }
53139   jresult = (void *)result;
53140   return jresult;
53141 }
53142
53143
53144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53145   void * jresult ;
53146   Dali::DragAndDropDetector *result = 0 ;
53147
53148   {
53149     try {
53150       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53151     } catch (std::out_of_range& e) {
53152       {
53153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53154       };
53155     } catch (std::exception& e) {
53156       {
53157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (...) {
53160       {
53161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53162       };
53163     }
53164   }
53165   jresult = (void *)result;
53166   return jresult;
53167 }
53168
53169
53170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53171   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53172
53173   arg1 = (Dali::DragAndDropDetector *)jarg1;
53174   {
53175     try {
53176       delete arg1;
53177     } catch (std::out_of_range& e) {
53178       {
53179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53180       };
53181     } catch (std::exception& e) {
53182       {
53183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53184       };
53185     } catch (...) {
53186       {
53187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53188       };
53189     }
53190   }
53191 }
53192
53193
53194 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53195   char * jresult ;
53196   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53197   std::string *result = 0 ;
53198
53199   arg1 = (Dali::DragAndDropDetector *)jarg1;
53200   {
53201     try {
53202       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53203     } catch (std::out_of_range& e) {
53204       {
53205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53206       };
53207     } catch (std::exception& e) {
53208       {
53209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53210       };
53211     } catch (...) {
53212       {
53213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53214       };
53215     }
53216   }
53217   jresult = SWIG_csharp_string_callback(result->c_str());
53218   return jresult;
53219 }
53220
53221
53222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53223   void * jresult ;
53224   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53225   Dali::Vector2 result;
53226
53227   arg1 = (Dali::DragAndDropDetector *)jarg1;
53228   {
53229     try {
53230       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53231     } catch (std::out_of_range& e) {
53232       {
53233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53234       };
53235     } catch (std::exception& e) {
53236       {
53237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (...) {
53240       {
53241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53242       };
53243     }
53244   }
53245   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53246   return jresult;
53247 }
53248
53249
53250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53251   void * jresult ;
53252   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53253   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53254
53255   arg1 = (Dali::DragAndDropDetector *)jarg1;
53256   {
53257     try {
53258       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53259     } catch (std::out_of_range& e) {
53260       {
53261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53262       };
53263     } catch (std::exception& e) {
53264       {
53265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53266       };
53267     } catch (...) {
53268       {
53269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53270       };
53271     }
53272   }
53273   jresult = (void *)result;
53274   return jresult;
53275 }
53276
53277
53278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53279   void * jresult ;
53280   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53281   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53282
53283   arg1 = (Dali::DragAndDropDetector *)jarg1;
53284   {
53285     try {
53286       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (...) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53298       };
53299     }
53300   }
53301   jresult = (void *)result;
53302   return jresult;
53303 }
53304
53305
53306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53307   void * jresult ;
53308   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53309   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53310
53311   arg1 = (Dali::DragAndDropDetector *)jarg1;
53312   {
53313     try {
53314       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53315     } catch (std::out_of_range& e) {
53316       {
53317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53318       };
53319     } catch (std::exception& e) {
53320       {
53321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53322       };
53323     } catch (...) {
53324       {
53325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53326       };
53327     }
53328   }
53329   jresult = (void *)result;
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53335   void * jresult ;
53336   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53337   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53338
53339   arg1 = (Dali::DragAndDropDetector *)jarg1;
53340   {
53341     try {
53342       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (...) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53354       };
53355     }
53356   }
53357   jresult = (void *)result;
53358   return jresult;
53359 }
53360
53361
53362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53363   void * jresult ;
53364   Dali::ApplicationExtensions *result = 0 ;
53365
53366   {
53367     try {
53368       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53369     } catch (std::out_of_range& e) {
53370       {
53371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53372       };
53373     } catch (std::exception& e) {
53374       {
53375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53376       };
53377     } catch (...) {
53378       {
53379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53380       };
53381     }
53382   }
53383   jresult = (void *)result;
53384   return jresult;
53385 }
53386
53387
53388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53389   void * jresult ;
53390   Dali::Application *arg1 = (Dali::Application *) 0 ;
53391   Dali::ApplicationExtensions *result = 0 ;
53392
53393   arg1 = (Dali::Application *)jarg1;
53394   {
53395     try {
53396       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53397     } catch (std::out_of_range& e) {
53398       {
53399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53400       };
53401     } catch (std::exception& e) {
53402       {
53403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53404       };
53405     } catch (...) {
53406       {
53407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53408       };
53409     }
53410   }
53411   jresult = (void *)result;
53412   return jresult;
53413 }
53414
53415
53416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53417   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53418
53419   arg1 = (Dali::ApplicationExtensions *)jarg1;
53420   {
53421     try {
53422       delete arg1;
53423     } catch (std::out_of_range& e) {
53424       {
53425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53426       };
53427     } catch (std::exception& e) {
53428       {
53429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53430       };
53431     } catch (...) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53434       };
53435     }
53436   }
53437 }
53438
53439
53440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53441   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53442
53443   arg1 = (Dali::ApplicationExtensions *)jarg1;
53444   {
53445     try {
53446       (arg1)->Init();
53447     } catch (std::out_of_range& e) {
53448       {
53449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (std::exception& e) {
53452       {
53453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (...) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53458       };
53459     }
53460   }
53461 }
53462
53463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
53464   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53465
53466   arg1 = (Dali::ApplicationExtensions *)jarg1;
53467   {
53468     try {
53469       (arg1)->Start();
53470     } catch (std::out_of_range& e) {
53471       {
53472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53473       };
53474     } catch (std::exception& e) {
53475       {
53476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53477       };
53478     } catch (...) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53481       };
53482     }
53483   }
53484 }
53485
53486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53487   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53488
53489   arg1 = (Dali::ApplicationExtensions *)jarg1;
53490   {
53491     try {
53492       (arg1)->Terminate();
53493     } catch (std::out_of_range& e) {
53494       {
53495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53496       };
53497     } catch (std::exception& e) {
53498       {
53499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53500       };
53501     } catch (...) {
53502       {
53503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53504       };
53505     }
53506   }
53507 }
53508
53509
53510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53511   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53512
53513   arg1 = (Dali::ApplicationExtensions *)jarg1;
53514   {
53515     try {
53516       (arg1)->Pause();
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_ApplicationExtensions_Resume(void * jarg1) {
53535   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53536
53537   arg1 = (Dali::ApplicationExtensions *)jarg1;
53538   {
53539     try {
53540       (arg1)->Resume();
53541     } catch (std::out_of_range& e) {
53542       {
53543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53544       };
53545     } catch (std::exception& e) {
53546       {
53547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53548       };
53549     } catch (...) {
53550       {
53551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53552       };
53553     }
53554   }
53555 }
53556
53557
53558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53559   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53560
53561   arg1 = (Dali::ApplicationExtensions *)jarg1;
53562   {
53563     try {
53564       (arg1)->LanguageChange();
53565     } catch (std::out_of_range& e) {
53566       {
53567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53568       };
53569     } catch (std::exception& e) {
53570       {
53571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53572       };
53573     } catch (...) {
53574       {
53575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53576       };
53577     }
53578   }
53579 }
53580
53581
53582
53583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
53584   unsigned int jresult ;
53585   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53586   bool result;
53587
53588   arg1 = (Dali::Signal< bool () > *)jarg1;
53589   {
53590     try {
53591       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
53592     } catch (std::out_of_range& e) {
53593       {
53594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (std::exception& e) {
53597       {
53598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53599       };
53600     } catch (...) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53603       };
53604     }
53605   }
53606   jresult = result;
53607   return jresult;
53608 }
53609
53610
53611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
53612   unsigned long jresult ;
53613   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53614   std::size_t result;
53615
53616   arg1 = (Dali::Signal< bool () > *)jarg1;
53617   {
53618     try {
53619       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
53620     } catch (std::out_of_range& e) {
53621       {
53622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53623       };
53624     } catch (std::exception& e) {
53625       {
53626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53627       };
53628     } catch (...) {
53629       {
53630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53631       };
53632     }
53633   }
53634   jresult = (unsigned long)result;
53635   return jresult;
53636 }
53637
53638
53639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
53640   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53641   bool (*arg2)() = (bool (*)()) 0 ;
53642
53643   arg1 = (Dali::Signal< bool () > *)jarg1;
53644   arg2 = (bool (*)())jarg2;
53645   {
53646     try {
53647       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
53648     } catch (std::out_of_range& e) {
53649       {
53650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53651       };
53652     } catch (std::exception& e) {
53653       {
53654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53655       };
53656     } catch (...) {
53657       {
53658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53659       };
53660     }
53661   }
53662 }
53663
53664
53665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
53666   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53667   bool (*arg2)() = (bool (*)()) 0 ;
53668
53669   arg1 = (Dali::Signal< bool () > *)jarg1;
53670   arg2 = (bool (*)())jarg2;
53671   {
53672     try {
53673       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53681       };
53682     } catch (...) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53685       };
53686     }
53687   }
53688 }
53689
53690
53691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
53692   unsigned int jresult ;
53693   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53694   bool result;
53695
53696   arg1 = (Dali::Signal< bool () > *)jarg1;
53697   {
53698     try {
53699       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
53700     } catch (std::out_of_range& e) {
53701       {
53702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53703       };
53704     } catch (std::exception& e) {
53705       {
53706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53707       };
53708     } catch (...) {
53709       {
53710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53711       };
53712     }
53713   }
53714   jresult = result;
53715   return jresult;
53716 }
53717
53718
53719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
53720   void * jresult ;
53721   Dali::Signal< bool () > *result = 0 ;
53722
53723   {
53724     try {
53725       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
53726     } catch (std::out_of_range& e) {
53727       {
53728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53729       };
53730     } catch (std::exception& e) {
53731       {
53732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53733       };
53734     } catch (...) {
53735       {
53736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53737       };
53738     }
53739   }
53740   jresult = (void *)result;
53741   return jresult;
53742 }
53743
53744
53745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
53746   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53747
53748   arg1 = (Dali::Signal< bool () > *)jarg1;
53749   {
53750     try {
53751       delete arg1;
53752     } catch (std::out_of_range& e) {
53753       {
53754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (std::exception& e) {
53757       {
53758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53763       };
53764     }
53765   }
53766 }
53767
53768
53769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
53770   int jresult ;
53771   int result;
53772
53773   {
53774     try {
53775       result = (int)Dali::Toolkit::Visual::Property::TYPE;
53776     } catch (std::out_of_range& e) {
53777       {
53778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53779       };
53780     } catch (std::exception& e) {
53781       {
53782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (...) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53787       };
53788     }
53789   }
53790   jresult = (int)result;
53791   return jresult;
53792 }
53793
53794
53795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
53796   int jresult ;
53797   int result;
53798
53799   {
53800     try {
53801       result = (int)Dali::Toolkit::Visual::Property::SHADER;
53802     } catch (std::out_of_range& e) {
53803       {
53804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53805       };
53806     } catch (std::exception& e) {
53807       {
53808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53809       };
53810     } catch (...) {
53811       {
53812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53813       };
53814     }
53815   }
53816   jresult = (int)result;
53817   return jresult;
53818 }
53819
53820
53821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
53822   int jresult ;
53823   int result;
53824
53825   {
53826     try {
53827       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
53828     } catch (std::out_of_range& e) {
53829       {
53830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53831       };
53832     } catch (std::exception& e) {
53833       {
53834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53835       };
53836     } catch (...) {
53837       {
53838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53839       };
53840     }
53841   }
53842   jresult = (int)result;
53843   return jresult;
53844 }
53845
53846
53847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
53848   int jresult ;
53849   int result;
53850
53851   {
53852     try {
53853       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
53854     } catch (std::out_of_range& e) {
53855       {
53856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53857       };
53858     } catch (std::exception& e) {
53859       {
53860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53861       };
53862     } catch (...) {
53863       {
53864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53865       };
53866     }
53867   }
53868   jresult = (int)result;
53869   return jresult;
53870 }
53871
53872
53873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
53874   int jresult ;
53875   int result;
53876
53877   {
53878     try {
53879       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
53880     } catch (std::out_of_range& e) {
53881       {
53882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53883       };
53884     } catch (std::exception& e) {
53885       {
53886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53887       };
53888     } catch (...) {
53889       {
53890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53891       };
53892     }
53893   }
53894   jresult = (int)result;
53895   return jresult;
53896 }
53897
53898
53899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
53900   int jresult ;
53901   int result;
53902
53903   {
53904     try {
53905       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53913       };
53914     } catch (...) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53917       };
53918     }
53919   }
53920   jresult = (int)result;
53921   return jresult;
53922 }
53923
53924
53925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
53926   int jresult ;
53927   int result;
53928
53929   {
53930     try {
53931       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
53932     } catch (std::out_of_range& e) {
53933       {
53934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53935       };
53936     } catch (std::exception& e) {
53937       {
53938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53939       };
53940     } catch (...) {
53941       {
53942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53943       };
53944     }
53945   }
53946   jresult = (int)result;
53947   return jresult;
53948 }
53949
53950
53951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
53952   int jresult ;
53953   int result;
53954
53955   {
53956     try {
53957       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
53958     } catch (std::out_of_range& e) {
53959       {
53960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53961       };
53962     } catch (std::exception& e) {
53963       {
53964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53965       };
53966     } catch (...) {
53967       {
53968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53969       };
53970     }
53971   }
53972   jresult = (int)result;
53973   return jresult;
53974 }
53975
53976
53977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
53978   int jresult ;
53979   int result;
53980
53981   {
53982     try {
53983       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
53984     } catch (std::out_of_range& e) {
53985       {
53986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53987       };
53988     } catch (std::exception& e) {
53989       {
53990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53991       };
53992     } catch (...) {
53993       {
53994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53995       };
53996     }
53997   }
53998   jresult = (int)result;
53999   return jresult;
54000 }
54001
54002
54003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
54004   int jresult ;
54005   int result;
54006
54007   {
54008     try {
54009       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
54010     } catch (std::out_of_range& e) {
54011       {
54012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54013       };
54014     } catch (std::exception& e) {
54015       {
54016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54017       };
54018     } catch (...) {
54019       {
54020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54021       };
54022     }
54023   }
54024   jresult = (int)result;
54025   return jresult;
54026 }
54027
54028
54029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
54030   int jresult ;
54031   int result;
54032
54033   {
54034     try {
54035       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
54036     } catch (std::out_of_range& e) {
54037       {
54038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54039       };
54040     } catch (std::exception& e) {
54041       {
54042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54043       };
54044     } catch (...) {
54045       {
54046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54047       };
54048     }
54049   }
54050   jresult = (int)result;
54051   return jresult;
54052 }
54053
54054
54055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
54056   int jresult ;
54057   int result;
54058
54059   {
54060     try {
54061       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
54062     } catch (std::out_of_range& e) {
54063       {
54064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54065       };
54066     } catch (std::exception& e) {
54067       {
54068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54069       };
54070     } catch (...) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54073       };
54074     }
54075   }
54076   jresult = (int)result;
54077   return jresult;
54078 }
54079
54080
54081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
54082   int jresult ;
54083   int result;
54084
54085   {
54086     try {
54087       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
54088     } catch (std::out_of_range& e) {
54089       {
54090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54091       };
54092     } catch (std::exception& e) {
54093       {
54094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (...) {
54097       {
54098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54099       };
54100     }
54101   }
54102   jresult = (int)result;
54103   return jresult;
54104 }
54105
54106
54107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
54108   int jresult ;
54109   int result;
54110
54111   {
54112     try {
54113       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
54114     } catch (std::out_of_range& e) {
54115       {
54116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54117       };
54118     } catch (std::exception& e) {
54119       {
54120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54121       };
54122     } catch (...) {
54123       {
54124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54125       };
54126     }
54127   }
54128   jresult = (int)result;
54129   return jresult;
54130 }
54131
54132
54133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
54134   int jresult ;
54135   int result;
54136
54137   {
54138     try {
54139       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
54140     } catch (std::out_of_range& e) {
54141       {
54142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54143       };
54144     } catch (std::exception& e) {
54145       {
54146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54147       };
54148     } catch (...) {
54149       {
54150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54151       };
54152     }
54153   }
54154   jresult = (int)result;
54155   return jresult;
54156 }
54157
54158
54159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
54160   int jresult ;
54161   int result;
54162
54163   {
54164     try {
54165       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
54166     } catch (std::out_of_range& e) {
54167       {
54168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54169       };
54170     } catch (std::exception& e) {
54171       {
54172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54173       };
54174     } catch (...) {
54175       {
54176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54177       };
54178     }
54179   }
54180   jresult = (int)result;
54181   return jresult;
54182 }
54183
54184
54185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
54186   int jresult ;
54187   int result;
54188
54189   {
54190     try {
54191       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
54192     } catch (std::out_of_range& e) {
54193       {
54194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54195       };
54196     } catch (std::exception& e) {
54197       {
54198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54199       };
54200     } catch (...) {
54201       {
54202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54203       };
54204     }
54205   }
54206   jresult = (int)result;
54207   return jresult;
54208 }
54209
54210
54211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
54212   int jresult ;
54213   int result;
54214
54215   {
54216     try {
54217       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
54218     } catch (std::out_of_range& e) {
54219       {
54220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54221       };
54222     } catch (std::exception& e) {
54223       {
54224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54225       };
54226     } catch (...) {
54227       {
54228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54229       };
54230     }
54231   }
54232   jresult = (int)result;
54233   return jresult;
54234 }
54235
54236
54237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
54238   int jresult ;
54239   int result;
54240
54241   {
54242     try {
54243       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
54244     } catch (std::out_of_range& e) {
54245       {
54246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54247       };
54248     } catch (std::exception& e) {
54249       {
54250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54251       };
54252     } catch (...) {
54253       {
54254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54255       };
54256     }
54257   }
54258   jresult = (int)result;
54259   return jresult;
54260 }
54261
54262
54263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
54264   int jresult ;
54265   int result;
54266
54267   {
54268     try {
54269       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
54270     } catch (std::out_of_range& e) {
54271       {
54272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54273       };
54274     } catch (std::exception& e) {
54275       {
54276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54277       };
54278     } catch (...) {
54279       {
54280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54281       };
54282     }
54283   }
54284   jresult = (int)result;
54285   return jresult;
54286 }
54287
54288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
54289   int jresult ;
54290   int result;
54291
54292   {
54293     try {
54294       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
54295     } catch (std::out_of_range& e) {
54296       {
54297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54298       };
54299     } catch (std::exception& e) {
54300       {
54301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54302       };
54303     } catch (...) {
54304       {
54305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54306       };
54307     }
54308   }
54309   jresult = (int)result;
54310   return jresult;
54311 }
54312
54313
54314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
54315   int jresult ;
54316   int result;
54317   {
54318     try
54319     {
54320       result = (int)Dali::Toolkit::DevelImageVisual::Property::BATCH_SIZE;
54321     } catch (std::out_of_range& e) {
54322       {
54323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54324       };
54325     } catch (std::exception& e) {
54326       {
54327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54328       };
54329     } catch (...) {
54330       {
54331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54332       };
54333     }
54334   }
54335   jresult = (int)result;
54336   return jresult;
54337 }
54338
54339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
54340   int jresult ;
54341   int result;
54342   {
54343     try
54344     {
54345       result = (int)Dali::Toolkit::DevelImageVisual::Property::CACHE_SIZE;
54346     } catch (std::out_of_range& e) {
54347       {
54348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (std::exception& e) {
54351       {
54352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (...) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54357       };
54358     }
54359   }
54360   jresult = (int)result;
54361   return jresult;
54362 }
54363
54364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
54365   int jresult ;
54366   int result;
54367   {
54368     try
54369     {
54370       result = (int)Dali::Toolkit::DevelImageVisual::Property::FRAME_DELAY;
54371     } catch (std::out_of_range& e) {
54372       {
54373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54374       };
54375     } catch (std::exception& e) {
54376       {
54377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54378       };
54379     } catch (...) {
54380       {
54381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54382       };
54383     }
54384   }
54385   jresult = (int)result;
54386   return jresult;
54387 }
54388
54389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
54390   int jresult ;
54391   int result;
54392   {
54393     try
54394     {
54395       result = (int)Dali::Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE;
54396     } catch (std::out_of_range& e) {
54397       {
54398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54399       };
54400     } catch (std::exception& e) {
54401       {
54402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54403       };
54404     } catch (...) {
54405       {
54406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54407       };
54408     }
54409   }
54410   jresult = (int)result;
54411   return jresult;
54412 }
54413
54414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
54415   int jresult ;
54416   int result;
54417   {
54418     try
54419     {
54420       result = (int)Dali::Toolkit::DevelImageVisual::Property::CROP_TO_MASK;
54421     } catch (std::out_of_range& e) {
54422       {
54423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54424       };
54425     } catch (std::exception& e) {
54426       {
54427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54428       };
54429     } catch (...) {
54430       {
54431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54432       };
54433     }
54434   }
54435   jresult = (int)result;
54436   return jresult;
54437 }
54438
54439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
54440   int jresult ;
54441   int result;
54442
54443   {
54444     try {
54445       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
54446     } catch (std::out_of_range& e) {
54447       {
54448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54449       };
54450     } catch (std::exception& e) {
54451       {
54452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54453       };
54454     } catch (...) {
54455       {
54456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54457       };
54458     }
54459   }
54460   jresult = (int)result;
54461   return jresult;
54462 }
54463
54464
54465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
54466   int jresult ;
54467   int result;
54468
54469   {
54470     try {
54471       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (...) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54483       };
54484     }
54485   }
54486   jresult = (int)result;
54487   return jresult;
54488 }
54489
54490
54491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
54492   int jresult ;
54493   int result;
54494
54495   {
54496     try {
54497       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
54498     } catch (std::out_of_range& e) {
54499       {
54500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54501       };
54502     } catch (std::exception& e) {
54503       {
54504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54505       };
54506     } catch (...) {
54507       {
54508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54509       };
54510     }
54511   }
54512   jresult = (int)result;
54513   return jresult;
54514 }
54515
54516
54517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
54518   int jresult ;
54519   int result;
54520
54521   {
54522     try {
54523       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
54524     } catch (std::out_of_range& e) {
54525       {
54526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54527       };
54528     } catch (std::exception& e) {
54529       {
54530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54531       };
54532     } catch (...) {
54533       {
54534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54535       };
54536     }
54537   }
54538   jresult = (int)result;
54539   return jresult;
54540 }
54541
54542
54543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
54544   int jresult ;
54545   int result;
54546
54547   {
54548     try {
54549       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
54550     } catch (std::out_of_range& e) {
54551       {
54552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54553       };
54554     } catch (std::exception& e) {
54555       {
54556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54557       };
54558     } catch (...) {
54559       {
54560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54561       };
54562     }
54563   }
54564   jresult = (int)result;
54565   return jresult;
54566 }
54567
54568
54569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
54570   int jresult ;
54571   int result;
54572
54573   {
54574     try {
54575       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
54576     } catch (std::out_of_range& e) {
54577       {
54578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54579       };
54580     } catch (std::exception& e) {
54581       {
54582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54583       };
54584     } catch (...) {
54585       {
54586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54587       };
54588     }
54589   }
54590   jresult = (int)result;
54591   return jresult;
54592 }
54593
54594
54595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
54596   int jresult ;
54597   int result;
54598
54599   {
54600     try {
54601       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
54602     } catch (std::out_of_range& e) {
54603       {
54604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54605       };
54606     } catch (std::exception& e) {
54607       {
54608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54609       };
54610     } catch (...) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54613       };
54614     }
54615   }
54616   jresult = (int)result;
54617   return jresult;
54618 }
54619
54620
54621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
54622   int jresult ;
54623   int result;
54624
54625   {
54626     try {
54627       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
54628     } catch (std::out_of_range& e) {
54629       {
54630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54631       };
54632     } catch (std::exception& e) {
54633       {
54634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54635       };
54636     } catch (...) {
54637       {
54638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54639       };
54640     }
54641   }
54642   jresult = (int)result;
54643   return jresult;
54644 }
54645
54646
54647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
54648   int jresult ;
54649   int result;
54650
54651   {
54652     try {
54653       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
54654     } catch (std::out_of_range& e) {
54655       {
54656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54657       };
54658     } catch (std::exception& e) {
54659       {
54660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54661       };
54662     } catch (...) {
54663       {
54664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54665       };
54666     }
54667   }
54668   jresult = (int)result;
54669   return jresult;
54670 }
54671
54672
54673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
54674   int jresult ;
54675   int result;
54676
54677   {
54678     try {
54679       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
54680     } catch (std::out_of_range& e) {
54681       {
54682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54683       };
54684     } catch (std::exception& e) {
54685       {
54686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54687       };
54688     } catch (...) {
54689       {
54690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54691       };
54692     }
54693   }
54694   jresult = (int)result;
54695   return jresult;
54696 }
54697
54698
54699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
54700   int jresult ;
54701   int result;
54702
54703   {
54704     try {
54705       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
54706     } catch (std::out_of_range& e) {
54707       {
54708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54709       };
54710     } catch (std::exception& e) {
54711       {
54712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54713       };
54714     } catch (...) {
54715       {
54716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54717       };
54718     }
54719   }
54720   jresult = (int)result;
54721   return jresult;
54722 }
54723
54724
54725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
54726   int jresult ;
54727   int result;
54728
54729   {
54730     try {
54731       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
54732     } catch (std::out_of_range& e) {
54733       {
54734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54735       };
54736     } catch (std::exception& e) {
54737       {
54738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54739       };
54740     } catch (...) {
54741       {
54742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54743       };
54744     }
54745   }
54746   jresult = (int)result;
54747   return jresult;
54748 }
54749
54750
54751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
54752   int jresult ;
54753   int result;
54754
54755   {
54756     try {
54757       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
54758     } catch (std::out_of_range& e) {
54759       {
54760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54761       };
54762     } catch (std::exception& e) {
54763       {
54764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54765       };
54766     } catch (...) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54769       };
54770     }
54771   }
54772   jresult = (int)result;
54773   return jresult;
54774 }
54775
54776
54777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
54778   int jresult ;
54779   int result;
54780
54781   {
54782     try {
54783       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
54784     } catch (std::out_of_range& e) {
54785       {
54786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54787       };
54788     } catch (std::exception& e) {
54789       {
54790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (...) {
54793       {
54794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54795       };
54796     }
54797   }
54798   jresult = (int)result;
54799   return jresult;
54800 }
54801
54802
54803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
54804   int jresult ;
54805   int result;
54806
54807   {
54808     try {
54809       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
54810     } catch (std::out_of_range& e) {
54811       {
54812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54813       };
54814     } catch (std::exception& e) {
54815       {
54816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54817       };
54818     } catch (...) {
54819       {
54820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54821       };
54822     }
54823   }
54824   jresult = (int)result;
54825   return jresult;
54826 }
54827
54828
54829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
54830   int jresult ;
54831   int result;
54832
54833   {
54834     try {
54835       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
54836     } catch (std::out_of_range& e) {
54837       {
54838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54839       };
54840     } catch (std::exception& e) {
54841       {
54842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54843       };
54844     } catch (...) {
54845       {
54846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54847       };
54848     }
54849   }
54850   jresult = (int)result;
54851   return jresult;
54852 }
54853
54854
54855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
54856   int jresult ;
54857   int result;
54858
54859   {
54860     try {
54861       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
54862     } catch (std::out_of_range& e) {
54863       {
54864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54865       };
54866     } catch (std::exception& e) {
54867       {
54868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54869       };
54870     } catch (...) {
54871       {
54872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54873       };
54874     }
54875   }
54876   jresult = (int)result;
54877   return jresult;
54878 }
54879
54880
54881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
54882   int jresult ;
54883   int result;
54884
54885   {
54886     try {
54887       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
54888     } catch (std::out_of_range& e) {
54889       {
54890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54891       };
54892     } catch (std::exception& e) {
54893       {
54894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54895       };
54896     } catch (...) {
54897       {
54898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54899       };
54900     }
54901   }
54902   jresult = (int)result;
54903   return jresult;
54904 }
54905
54906
54907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
54908   int jresult ;
54909   int result;
54910
54911   {
54912     try {
54913       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
54914     } catch (std::out_of_range& e) {
54915       {
54916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (std::exception& e) {
54919       {
54920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (...) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54925       };
54926     }
54927   }
54928   jresult = (int)result;
54929   return jresult;
54930 }
54931
54932
54933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
54934   int jresult ;
54935   int result;
54936
54937   {
54938     try {
54939       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
54940     } catch (std::out_of_range& e) {
54941       {
54942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54943       };
54944     } catch (std::exception& e) {
54945       {
54946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54947       };
54948     } catch (...) {
54949       {
54950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54951       };
54952     }
54953   }
54954   jresult = (int)result;
54955   return jresult;
54956 }
54957
54958
54959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
54960   int jresult ;
54961   int result;
54962
54963   {
54964     try {
54965       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
54966     } catch (std::out_of_range& e) {
54967       {
54968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54969       };
54970     } catch (std::exception& e) {
54971       {
54972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54973       };
54974     } catch (...) {
54975       {
54976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54977       };
54978     }
54979   }
54980   jresult = (int)result;
54981   return jresult;
54982 }
54983
54984
54985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
54986   int jresult ;
54987   int result;
54988
54989   {
54990     try {
54991       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
54992     } catch (std::out_of_range& e) {
54993       {
54994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54995       };
54996     } catch (std::exception& e) {
54997       {
54998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54999       };
55000     } catch (...) {
55001       {
55002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55003       };
55004     }
55005   }
55006   jresult = (int)result;
55007   return jresult;
55008 }
55009
55010
55011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
55012   int jresult ;
55013   int result;
55014
55015   {
55016     try {
55017       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
55018     } catch (std::out_of_range& e) {
55019       {
55020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55021       };
55022     } catch (std::exception& e) {
55023       {
55024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55025       };
55026     } catch (...) {
55027       {
55028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55029       };
55030     }
55031   }
55032   jresult = (int)result;
55033   return jresult;
55034 }
55035
55036
55037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
55038   int jresult ;
55039   int result;
55040
55041   {
55042     try {
55043       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
55044     } catch (std::out_of_range& e) {
55045       {
55046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55047       };
55048     } catch (std::exception& e) {
55049       {
55050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55051       };
55052     } catch (...) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55055       };
55056     }
55057   }
55058   jresult = (int)result;
55059   return jresult;
55060 }
55061
55062
55063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
55064   int jresult ;
55065   int result;
55066
55067   {
55068     try {
55069       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (...) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55081       };
55082     }
55083   }
55084   jresult = (int)result;
55085   return jresult;
55086 }
55087
55088
55089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
55090   int jresult ;
55091   int result;
55092
55093   {
55094     try {
55095       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
55096     } catch (std::out_of_range& e) {
55097       {
55098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55099       };
55100     } catch (std::exception& e) {
55101       {
55102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55103       };
55104     } catch (...) {
55105       {
55106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55107       };
55108     }
55109   }
55110   jresult = (int)result;
55111   return jresult;
55112 }
55113
55114
55115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
55116   int jresult ;
55117   int result;
55118
55119   {
55120     try {
55121       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
55122     } catch (std::out_of_range& e) {
55123       {
55124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55125       };
55126     } catch (std::exception& e) {
55127       {
55128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55129       };
55130     } catch (...) {
55131       {
55132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55133       };
55134     }
55135   }
55136   jresult = (int)result;
55137   return jresult;
55138 }
55139
55140
55141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
55142   int jresult ;
55143   int result;
55144
55145   {
55146     try {
55147       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
55148     } catch (std::out_of_range& e) {
55149       {
55150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55151       };
55152     } catch (std::exception& e) {
55153       {
55154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55155       };
55156     } catch (...) {
55157       {
55158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55159       };
55160     }
55161   }
55162   jresult = (int)result;
55163   return jresult;
55164 }
55165
55166
55167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
55168   int jresult ;
55169   int result;
55170
55171   {
55172     try {
55173       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55181       };
55182     } catch (...) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55185       };
55186     }
55187   }
55188   jresult = (int)result;
55189   return jresult;
55190 }
55191
55192
55193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
55194   int jresult ;
55195   int result;
55196
55197   {
55198     try {
55199       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
55200     } catch (std::out_of_range& e) {
55201       {
55202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55203       };
55204     } catch (std::exception& e) {
55205       {
55206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55207       };
55208     } catch (...) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55211       };
55212     }
55213   }
55214   jresult = (int)result;
55215   return jresult;
55216 }
55217
55218
55219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
55220   int jresult ;
55221   int result;
55222
55223   {
55224     try {
55225       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
55226     } catch (std::out_of_range& e) {
55227       {
55228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55229       };
55230     } catch (std::exception& e) {
55231       {
55232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55233       };
55234     } catch (...) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55237       };
55238     }
55239   }
55240   jresult = (int)result;
55241   return jresult;
55242 }
55243
55244
55245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
55246   int jresult ;
55247   int result;
55248
55249   {
55250     try {
55251       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
55252     } catch (std::out_of_range& e) {
55253       {
55254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55255       };
55256     } catch (std::exception& e) {
55257       {
55258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55259       };
55260     } catch (...) {
55261       {
55262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55263       };
55264     }
55265   }
55266   jresult = (int)result;
55267   return jresult;
55268 }
55269
55270
55271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
55272   int jresult ;
55273   int result;
55274
55275   {
55276     try {
55277       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
55278     } catch (std::out_of_range& e) {
55279       {
55280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55281       };
55282     } catch (std::exception& e) {
55283       {
55284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55285       };
55286     } catch (...) {
55287       {
55288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55289       };
55290     }
55291   }
55292   jresult = (int)result;
55293   return jresult;
55294 }
55295
55296
55297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
55298   int jresult ;
55299   int result;
55300
55301   {
55302     try {
55303       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
55304     } catch (std::out_of_range& e) {
55305       {
55306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (std::exception& e) {
55309       {
55310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (...) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55315       };
55316     }
55317   }
55318   jresult = (int)result;
55319   return jresult;
55320 }
55321
55322
55323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
55324   int jresult ;
55325   int result;
55326
55327   {
55328     try {
55329       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
55330     } catch (std::out_of_range& e) {
55331       {
55332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55333       };
55334     } catch (std::exception& e) {
55335       {
55336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55337       };
55338     } catch (...) {
55339       {
55340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55341       };
55342     }
55343   }
55344   jresult = (int)result;
55345   return jresult;
55346 }
55347
55348
55349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
55350   int jresult ;
55351   int result;
55352
55353   {
55354     try {
55355       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
55356     } catch (std::out_of_range& e) {
55357       {
55358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (std::exception& e) {
55361       {
55362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55363       };
55364     } catch (...) {
55365       {
55366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55367       };
55368     }
55369   }
55370   jresult = (int)result;
55371   return jresult;
55372 }
55373
55374
55375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
55376   int jresult ;
55377   int result;
55378
55379   {
55380     try {
55381       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
55382     } catch (std::out_of_range& e) {
55383       {
55384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55385       };
55386     } catch (std::exception& e) {
55387       {
55388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55389       };
55390     } catch (...) {
55391       {
55392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55393       };
55394     }
55395   }
55396   jresult = (int)result;
55397   return jresult;
55398 }
55399
55400
55401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
55402   void * jresult ;
55403   Dali::Toolkit::Builder *result = 0 ;
55404
55405   {
55406     try {
55407       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
55408     } catch (std::out_of_range& e) {
55409       {
55410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55411       };
55412     } catch (std::exception& e) {
55413       {
55414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55415       };
55416     } catch (...) {
55417       {
55418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55419       };
55420     }
55421   }
55422   jresult = (void *)result;
55423   return jresult;
55424 }
55425
55426
55427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
55428   void * jresult ;
55429   Dali::Toolkit::Builder result;
55430
55431   {
55432     try {
55433       result = Dali::Toolkit::Builder::New();
55434     } catch (std::out_of_range& e) {
55435       {
55436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55437       };
55438     } catch (std::exception& e) {
55439       {
55440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55441       };
55442     } catch (...) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55445       };
55446     }
55447   }
55448   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
55449   return jresult;
55450 }
55451
55452
55453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
55454   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55455
55456   arg1 = (Dali::Toolkit::Builder *)jarg1;
55457   {
55458     try {
55459       delete arg1;
55460     } catch (std::out_of_range& e) {
55461       {
55462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55463       };
55464     } catch (std::exception& e) {
55465       {
55466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55467       };
55468     } catch (...) {
55469       {
55470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55471       };
55472     }
55473   }
55474 }
55475
55476
55477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
55478   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55479   std::string *arg2 = 0 ;
55480   Dali::Toolkit::Builder::UIFormat arg3 ;
55481
55482   arg1 = (Dali::Toolkit::Builder *)jarg1;
55483   if (!jarg2) {
55484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55485     return ;
55486   }
55487   std::string arg2_str(jarg2);
55488   arg2 = &arg2_str;
55489   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
55490   {
55491     try {
55492       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
55493     } catch (std::out_of_range& e) {
55494       {
55495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55496       };
55497     } catch (std::exception& e) {
55498       {
55499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55500       };
55501     } catch (...) {
55502       {
55503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55504       };
55505     }
55506   }
55507
55508   //argout typemap for const std::string&
55509
55510 }
55511
55512
55513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
55514   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55515   std::string *arg2 = 0 ;
55516
55517   arg1 = (Dali::Toolkit::Builder *)jarg1;
55518   if (!jarg2) {
55519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55520     return ;
55521   }
55522   std::string arg2_str(jarg2);
55523   arg2 = &arg2_str;
55524   {
55525     try {
55526       (arg1)->LoadFromString((std::string const &)*arg2);
55527     } catch (std::out_of_range& e) {
55528       {
55529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55530       };
55531     } catch (std::exception& e) {
55532       {
55533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55534       };
55535     } catch (...) {
55536       {
55537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55538       };
55539     }
55540   }
55541
55542   //argout typemap for const std::string&
55543
55544 }
55545
55546
55547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
55548   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55549   Dali::Property::Map *arg2 = 0 ;
55550
55551   arg1 = (Dali::Toolkit::Builder *)jarg1;
55552   arg2 = (Dali::Property::Map *)jarg2;
55553   if (!arg2) {
55554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55555     return ;
55556   }
55557   {
55558     try {
55559       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
55560     } catch (std::out_of_range& e) {
55561       {
55562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55563       };
55564     } catch (std::exception& e) {
55565       {
55566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55567       };
55568     } catch (...) {
55569       {
55570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55571       };
55572     }
55573   }
55574 }
55575
55576
55577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
55578   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55579   std::string *arg2 = 0 ;
55580   Dali::Property::Value *arg3 = 0 ;
55581
55582   arg1 = (Dali::Toolkit::Builder *)jarg1;
55583   if (!jarg2) {
55584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55585     return ;
55586   }
55587   std::string arg2_str(jarg2);
55588   arg2 = &arg2_str;
55589   arg3 = (Dali::Property::Value *)jarg3;
55590   if (!arg3) {
55591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
55592     return ;
55593   }
55594   {
55595     try {
55596       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
55597     } catch (std::out_of_range& e) {
55598       {
55599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55600       };
55601     } catch (std::exception& e) {
55602       {
55603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55604       };
55605     } catch (...) {
55606       {
55607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55608       };
55609     }
55610   }
55611
55612   //argout typemap for const std::string&
55613
55614 }
55615
55616
55617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
55618   void * jresult ;
55619   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55620   Dali::Property::Map *result = 0 ;
55621
55622   arg1 = (Dali::Toolkit::Builder *)jarg1;
55623   {
55624     try {
55625       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
55626     } catch (std::out_of_range& e) {
55627       {
55628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55629       };
55630     } catch (std::exception& e) {
55631       {
55632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55633       };
55634     } catch (...) {
55635       {
55636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55637       };
55638     }
55639   }
55640   jresult = (void *)result;
55641   return jresult;
55642 }
55643
55644
55645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
55646   void * jresult ;
55647   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55648   std::string *arg2 = 0 ;
55649   Dali::Property::Value *result = 0 ;
55650
55651   arg1 = (Dali::Toolkit::Builder *)jarg1;
55652   if (!jarg2) {
55653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55654     return 0;
55655   }
55656   std::string arg2_str(jarg2);
55657   arg2 = &arg2_str;
55658   {
55659     try {
55660       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
55661     } catch (std::out_of_range& e) {
55662       {
55663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55664       };
55665     } catch (std::exception& e) {
55666       {
55667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55668       };
55669     } catch (...) {
55670       {
55671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55672       };
55673     }
55674   }
55675   jresult = (void *)result;
55676
55677   //argout typemap for const std::string&
55678
55679   return jresult;
55680 }
55681
55682
55683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
55684   void * jresult ;
55685   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55686   std::string *arg2 = 0 ;
55687   Dali::Animation result;
55688
55689   arg1 = (Dali::Toolkit::Builder *)jarg1;
55690   if (!jarg2) {
55691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55692     return 0;
55693   }
55694   std::string arg2_str(jarg2);
55695   arg2 = &arg2_str;
55696   {
55697     try {
55698       result = (arg1)->CreateAnimation((std::string const &)*arg2);
55699     } catch (std::out_of_range& e) {
55700       {
55701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55702       };
55703     } catch (std::exception& e) {
55704       {
55705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55706       };
55707     } catch (...) {
55708       {
55709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55710       };
55711     }
55712   }
55713   jresult = new Dali::Animation((const Dali::Animation &)result);
55714
55715   //argout typemap for const std::string&
55716
55717   return jresult;
55718 }
55719
55720
55721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55722   void * jresult ;
55723   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55724   std::string *arg2 = 0 ;
55725   Dali::Property::Map *arg3 = 0 ;
55726   Dali::Animation result;
55727
55728   arg1 = (Dali::Toolkit::Builder *)jarg1;
55729   if (!jarg2) {
55730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55731     return 0;
55732   }
55733   std::string arg2_str(jarg2);
55734   arg2 = &arg2_str;
55735   arg3 = (Dali::Property::Map *)jarg3;
55736   if (!arg3) {
55737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55738     return 0;
55739   }
55740   {
55741     try {
55742       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
55743     } catch (std::out_of_range& e) {
55744       {
55745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55746       };
55747     } catch (std::exception& e) {
55748       {
55749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55750       };
55751     } catch (...) {
55752       {
55753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55754       };
55755     }
55756   }
55757   jresult = new Dali::Animation((const Dali::Animation &)result);
55758
55759   //argout typemap for const std::string&
55760
55761   return jresult;
55762 }
55763
55764
55765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
55766   void * jresult ;
55767   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55768   std::string *arg2 = 0 ;
55769   Dali::Actor arg3 ;
55770   Dali::Actor *argp3 ;
55771   Dali::Animation result;
55772
55773   arg1 = (Dali::Toolkit::Builder *)jarg1;
55774   if (!jarg2) {
55775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55776     return 0;
55777   }
55778   std::string arg2_str(jarg2);
55779   arg2 = &arg2_str;
55780   argp3 = (Dali::Actor *)jarg3;
55781   if (!argp3) {
55782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55783     return 0;
55784   }
55785   arg3 = *argp3;
55786   {
55787     try {
55788       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
55789     } catch (std::out_of_range& e) {
55790       {
55791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55792       };
55793     } catch (std::exception& e) {
55794       {
55795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (...) {
55798       {
55799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55800       };
55801     }
55802   }
55803   jresult = new Dali::Animation((const Dali::Animation &)result);
55804
55805   //argout typemap for const std::string&
55806
55807   return jresult;
55808 }
55809
55810
55811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
55812   void * jresult ;
55813   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55814   std::string *arg2 = 0 ;
55815   Dali::Property::Map *arg3 = 0 ;
55816   Dali::Actor arg4 ;
55817   Dali::Actor *argp4 ;
55818   Dali::Animation result;
55819
55820   arg1 = (Dali::Toolkit::Builder *)jarg1;
55821   if (!jarg2) {
55822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55823     return 0;
55824   }
55825   std::string arg2_str(jarg2);
55826   arg2 = &arg2_str;
55827   arg3 = (Dali::Property::Map *)jarg3;
55828   if (!arg3) {
55829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55830     return 0;
55831   }
55832   argp4 = (Dali::Actor *)jarg4;
55833   if (!argp4) {
55834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55835     return 0;
55836   }
55837   arg4 = *argp4;
55838   {
55839     try {
55840       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55848       };
55849     } catch (...) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55852       };
55853     }
55854   }
55855   jresult = new Dali::Animation((const Dali::Animation &)result);
55856
55857   //argout typemap for const std::string&
55858
55859   return jresult;
55860 }
55861
55862
55863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
55864   void * jresult ;
55865   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55866   std::string *arg2 = 0 ;
55867   Dali::BaseHandle result;
55868
55869   arg1 = (Dali::Toolkit::Builder *)jarg1;
55870   if (!jarg2) {
55871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55872     return 0;
55873   }
55874   std::string arg2_str(jarg2);
55875   arg2 = &arg2_str;
55876   {
55877     try {
55878       result = (arg1)->Create((std::string const &)*arg2);
55879     } catch (std::out_of_range& e) {
55880       {
55881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55882       };
55883     } catch (std::exception& e) {
55884       {
55885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55886       };
55887     } catch (...) {
55888       {
55889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55890       };
55891     }
55892   }
55893   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55894
55895   //argout typemap for const std::string&
55896
55897   return jresult;
55898 }
55899
55900
55901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55902   void * jresult ;
55903   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55904   std::string *arg2 = 0 ;
55905   Dali::Property::Map *arg3 = 0 ;
55906   Dali::BaseHandle result;
55907
55908   arg1 = (Dali::Toolkit::Builder *)jarg1;
55909   if (!jarg2) {
55910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55911     return 0;
55912   }
55913   std::string arg2_str(jarg2);
55914   arg2 = &arg2_str;
55915   arg3 = (Dali::Property::Map *)jarg3;
55916   if (!arg3) {
55917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55918     return 0;
55919   }
55920   {
55921     try {
55922       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
55923     } catch (std::out_of_range& e) {
55924       {
55925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55926       };
55927     } catch (std::exception& e) {
55928       {
55929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55930       };
55931     } catch (...) {
55932       {
55933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55934       };
55935     }
55936   }
55937   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55938
55939   //argout typemap for const std::string&
55940
55941   return jresult;
55942 }
55943
55944
55945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
55946   void * jresult ;
55947   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55948   std::string *arg2 = 0 ;
55949   Dali::BaseHandle result;
55950
55951   arg1 = (Dali::Toolkit::Builder *)jarg1;
55952   if (!jarg2) {
55953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55954     return 0;
55955   }
55956   std::string arg2_str(jarg2);
55957   arg2 = &arg2_str;
55958   {
55959     try {
55960       result = (arg1)->CreateFromJson((std::string const &)*arg2);
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (...) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55972       };
55973     }
55974   }
55975   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55976
55977   //argout typemap for const std::string&
55978
55979   return jresult;
55980 }
55981
55982
55983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
55984   unsigned int jresult ;
55985   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55986   std::string *arg2 = 0 ;
55987   Dali::Handle *arg3 = 0 ;
55988   bool result;
55989
55990   arg1 = (Dali::Toolkit::Builder *)jarg1;
55991   if (!jarg2) {
55992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55993     return 0;
55994   }
55995   std::string arg2_str(jarg2);
55996   arg2 = &arg2_str;
55997   arg3 = (Dali::Handle *)jarg3;
55998   if (!arg3) {
55999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
56000     return 0;
56001   }
56002   {
56003     try {
56004       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
56005     } catch (std::out_of_range& e) {
56006       {
56007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56008       };
56009     } catch (std::exception& e) {
56010       {
56011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56012       };
56013     } catch (...) {
56014       {
56015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56016       };
56017     }
56018   }
56019   jresult = result;
56020
56021   //argout typemap for const std::string&
56022
56023   return jresult;
56024 }
56025
56026
56027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
56028   unsigned int jresult ;
56029   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56030   Dali::Handle *arg2 = 0 ;
56031   std::string *arg3 = 0 ;
56032   bool result;
56033
56034   arg1 = (Dali::Toolkit::Builder *)jarg1;
56035   arg2 = (Dali::Handle *)jarg2;
56036   if (!arg2) {
56037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
56038     return 0;
56039   }
56040   if (!jarg3) {
56041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56042     return 0;
56043   }
56044   std::string arg3_str(jarg3);
56045   arg3 = &arg3_str;
56046   {
56047     try {
56048       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
56049     } catch (std::out_of_range& e) {
56050       {
56051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (std::exception& e) {
56054       {
56055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56060       };
56061     }
56062   }
56063   jresult = result;
56064
56065   //argout typemap for const std::string&
56066
56067   return jresult;
56068 }
56069
56070
56071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
56072   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56073   Dali::Actor arg2 ;
56074   Dali::Actor *argp2 ;
56075
56076   arg1 = (Dali::Toolkit::Builder *)jarg1;
56077   argp2 = (Dali::Actor *)jarg2;
56078   if (!argp2) {
56079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56080     return ;
56081   }
56082   arg2 = *argp2;
56083   {
56084     try {
56085       (arg1)->AddActors(arg2);
56086     } catch (std::out_of_range& e) {
56087       {
56088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56089       };
56090     } catch (std::exception& e) {
56091       {
56092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56093       };
56094     } catch (...) {
56095       {
56096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56097       };
56098     }
56099   }
56100 }
56101
56102
56103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
56104   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56105   std::string *arg2 = 0 ;
56106   Dali::Actor arg3 ;
56107   Dali::Actor *argp3 ;
56108
56109   arg1 = (Dali::Toolkit::Builder *)jarg1;
56110   if (!jarg2) {
56111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56112     return ;
56113   }
56114   std::string arg2_str(jarg2);
56115   arg2 = &arg2_str;
56116   argp3 = (Dali::Actor *)jarg3;
56117   if (!argp3) {
56118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56119     return ;
56120   }
56121   arg3 = *argp3;
56122   {
56123     try {
56124       (arg1)->AddActors((std::string const &)*arg2,arg3);
56125     } catch (std::out_of_range& e) {
56126       {
56127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56128       };
56129     } catch (std::exception& e) {
56130       {
56131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56132       };
56133     } catch (...) {
56134       {
56135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56136       };
56137     }
56138   }
56139
56140   //argout typemap for const std::string&
56141
56142 }
56143
56144
56145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
56146   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56147   std::string *arg2 = 0 ;
56148
56149   arg1 = (Dali::Toolkit::Builder *)jarg1;
56150   if (!jarg2) {
56151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56152     return ;
56153   }
56154   std::string arg2_str(jarg2);
56155   arg2 = &arg2_str;
56156   {
56157     try {
56158       (arg1)->CreateRenderTask((std::string const &)*arg2);
56159     } catch (std::out_of_range& e) {
56160       {
56161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56162       };
56163     } catch (std::exception& e) {
56164       {
56165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56166       };
56167     } catch (...) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56170       };
56171     }
56172   }
56173
56174   //argout typemap for const std::string&
56175
56176 }
56177
56178
56179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
56180   void * jresult ;
56181   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56182   std::string *arg2 = 0 ;
56183   Dali::FrameBufferImage result;
56184
56185   arg1 = (Dali::Toolkit::Builder *)jarg1;
56186   if (!jarg2) {
56187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56188     return 0;
56189   }
56190   std::string arg2_str(jarg2);
56191   arg2 = &arg2_str;
56192   {
56193     try {
56194       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
56195     } catch (std::out_of_range& e) {
56196       {
56197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56198       };
56199     } catch (std::exception& e) {
56200       {
56201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56202       };
56203     } catch (...) {
56204       {
56205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56206       };
56207     }
56208   }
56209   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
56210
56211   //argout typemap for const std::string&
56212
56213   return jresult;
56214 }
56215
56216
56217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
56218   void * jresult ;
56219   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56220   std::string *arg2 = 0 ;
56221   Dali::Path result;
56222
56223   arg1 = (Dali::Toolkit::Builder *)jarg1;
56224   if (!jarg2) {
56225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56226     return 0;
56227   }
56228   std::string arg2_str(jarg2);
56229   arg2 = &arg2_str;
56230   {
56231     try {
56232       result = (arg1)->GetPath((std::string const &)*arg2);
56233     } catch (std::out_of_range& e) {
56234       {
56235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56236       };
56237     } catch (std::exception& e) {
56238       {
56239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (...) {
56242       {
56243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56244       };
56245     }
56246   }
56247   jresult = new Dali::Path((const Dali::Path &)result);
56248
56249   //argout typemap for const std::string&
56250
56251   return jresult;
56252 }
56253
56254
56255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
56256   void * jresult ;
56257   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56258   std::string *arg2 = 0 ;
56259   Dali::PathConstrainer result;
56260
56261   arg1 = (Dali::Toolkit::Builder *)jarg1;
56262   if (!jarg2) {
56263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56264     return 0;
56265   }
56266   std::string arg2_str(jarg2);
56267   arg2 = &arg2_str;
56268   {
56269     try {
56270       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
56271     } catch (std::out_of_range& e) {
56272       {
56273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56274       };
56275     } catch (std::exception& e) {
56276       {
56277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56278       };
56279     } catch (...) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56282       };
56283     }
56284   }
56285   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
56286
56287   //argout typemap for const std::string&
56288
56289   return jresult;
56290 }
56291
56292
56293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
56294   void * jresult ;
56295   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56296   std::string *arg2 = 0 ;
56297   Dali::LinearConstrainer result;
56298
56299   arg1 = (Dali::Toolkit::Builder *)jarg1;
56300   if (!jarg2) {
56301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56302     return 0;
56303   }
56304   std::string arg2_str(jarg2);
56305   arg2 = &arg2_str;
56306   {
56307     try {
56308       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
56309     } catch (std::out_of_range& e) {
56310       {
56311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56312       };
56313     } catch (std::exception& e) {
56314       {
56315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56316       };
56317     } catch (...) {
56318       {
56319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56320       };
56321     }
56322   }
56323   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
56324
56325   //argout typemap for const std::string&
56326
56327   return jresult;
56328 }
56329
56330
56331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
56332   void * jresult ;
56333   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56334   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
56335
56336   arg1 = (Dali::Toolkit::Builder *)jarg1;
56337   {
56338     try {
56339       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
56340     } catch (std::out_of_range& e) {
56341       {
56342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56343       };
56344     } catch (std::exception& e) {
56345       {
56346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56347       };
56348     } catch (...) {
56349       {
56350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56351       };
56352     }
56353   }
56354   jresult = (void *)result;
56355   return jresult;
56356 }
56357
56358
56359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
56360   void * jresult ;
56361   Dali::Toolkit::TransitionData *result = 0 ;
56362
56363   {
56364     try {
56365       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
56366     } catch (std::out_of_range& e) {
56367       {
56368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (std::exception& e) {
56371       {
56372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56373       };
56374     } catch (...) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56377       };
56378     }
56379   }
56380   jresult = (void *)result;
56381   return jresult;
56382 }
56383
56384
56385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
56386   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56387
56388   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56389   {
56390     try {
56391       delete arg1;
56392     } catch (std::out_of_range& e) {
56393       {
56394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56395       };
56396     } catch (std::exception& e) {
56397       {
56398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56399       };
56400     } catch (...) {
56401       {
56402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56403       };
56404     }
56405   }
56406 }
56407
56408
56409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
56410   void * jresult ;
56411   Dali::Property::Map *arg1 = 0 ;
56412   Dali::Toolkit::TransitionData result;
56413
56414   arg1 = (Dali::Property::Map *)jarg1;
56415   if (!arg1) {
56416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56417     return 0;
56418   }
56419   {
56420     try {
56421       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
56422     } catch (std::out_of_range& e) {
56423       {
56424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56425       };
56426     } catch (std::exception& e) {
56427       {
56428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56429       };
56430     } catch (...) {
56431       {
56432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56433       };
56434     }
56435   }
56436   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56437   return jresult;
56438 }
56439
56440
56441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
56442   void * jresult ;
56443   Dali::Property::Array *arg1 = 0 ;
56444   Dali::Toolkit::TransitionData result;
56445
56446   arg1 = (Dali::Property::Array *)jarg1;
56447   if (!arg1) {
56448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
56449     return 0;
56450   }
56451   {
56452     try {
56453       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (...) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56465       };
56466     }
56467   }
56468   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56469   return jresult;
56470 }
56471
56472
56473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
56474   void * jresult ;
56475   Dali::BaseHandle arg1 ;
56476   Dali::BaseHandle *argp1 ;
56477   Dali::Toolkit::TransitionData result;
56478
56479   argp1 = (Dali::BaseHandle *)jarg1;
56480   if (!argp1) {
56481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
56482     return 0;
56483   }
56484   arg1 = *argp1;
56485   {
56486     try {
56487       result = Dali::Toolkit::TransitionData::DownCast(arg1);
56488     } catch (std::out_of_range& e) {
56489       {
56490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56491       };
56492     } catch (std::exception& e) {
56493       {
56494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (...) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56499       };
56500     }
56501   }
56502   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56503   return jresult;
56504 }
56505
56506
56507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
56508   void * jresult ;
56509   Dali::Toolkit::TransitionData *arg1 = 0 ;
56510   Dali::Toolkit::TransitionData *result = 0 ;
56511
56512   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56513   if (!arg1) {
56514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
56515     return 0;
56516   }
56517   {
56518     try {
56519       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
56520     } catch (std::out_of_range& e) {
56521       {
56522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (std::exception& e) {
56525       {
56526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56531       };
56532     }
56533   }
56534   jresult = (void *)result;
56535   return jresult;
56536 }
56537
56538
56539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
56540   void * jresult ;
56541   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56542   Dali::Toolkit::TransitionData *arg2 = 0 ;
56543   Dali::Toolkit::TransitionData *result = 0 ;
56544
56545   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56546   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
56547   if (!arg2) {
56548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
56549     return 0;
56550   }
56551   {
56552     try {
56553       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
56554     } catch (std::out_of_range& e) {
56555       {
56556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56557       };
56558     } catch (std::exception& e) {
56559       {
56560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56561       };
56562     } catch (...) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56565       };
56566     }
56567   }
56568   jresult = (void *)result;
56569   return jresult;
56570 }
56571
56572
56573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
56574   unsigned long jresult ;
56575   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56576   size_t result;
56577
56578   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56579   {
56580     try {
56581       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
56582     } catch (std::out_of_range& e) {
56583       {
56584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56585       };
56586     } catch (std::exception& e) {
56587       {
56588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56589       };
56590     } catch (...) {
56591       {
56592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56593       };
56594     }
56595   }
56596   jresult = (unsigned long)result;
56597   return jresult;
56598 }
56599
56600
56601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
56602   void * jresult ;
56603   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56604   size_t arg2 ;
56605   Dali::Property::Map result;
56606
56607   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56608   arg2 = (size_t)jarg2;
56609   {
56610     try {
56611       result = (arg1)->GetAnimatorAt(arg2);
56612     } catch (std::out_of_range& e) {
56613       {
56614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56615       };
56616     } catch (std::exception& e) {
56617       {
56618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (...) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56623       };
56624     }
56625   }
56626   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
56627   return jresult;
56628 }
56629
56630
56631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
56632   void * jresult ;
56633   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
56634   Dali::Toolkit::TransitionData *result = 0 ;
56635
56636   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
56637   {
56638     try {
56639       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
56640     } catch (std::out_of_range& e) {
56641       {
56642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56643       };
56644     } catch (std::exception& e) {
56645       {
56646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56647       };
56648     } catch (...) {
56649       {
56650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56651       };
56652     }
56653   }
56654   jresult = (void *)result;
56655   return jresult;
56656 }
56657
56658
56659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
56660   int jresult ;
56661   int result;
56662
56663   {
56664     try {
56665       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
56666     } catch (std::out_of_range& e) {
56667       {
56668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56669       };
56670     } catch (std::exception& e) {
56671       {
56672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56673       };
56674     } catch (...) {
56675       {
56676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56677       };
56678     }
56679   }
56680   jresult = (int)result;
56681   return jresult;
56682 }
56683
56684
56685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
56686   int jresult ;
56687   int result;
56688
56689   {
56690     try {
56691       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
56692     } catch (std::out_of_range& e) {
56693       {
56694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56695       };
56696     } catch (std::exception& e) {
56697       {
56698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56699       };
56700     } catch (...) {
56701       {
56702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56703       };
56704     }
56705   }
56706   jresult = (int)result;
56707   return jresult;
56708 }
56709
56710
56711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
56712   int jresult ;
56713   int result;
56714
56715   {
56716     try {
56717       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
56718     } catch (std::out_of_range& e) {
56719       {
56720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56721       };
56722     } catch (std::exception& e) {
56723       {
56724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56725       };
56726     } catch (...) {
56727       {
56728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56729       };
56730     }
56731   }
56732   jresult = (int)result;
56733   return jresult;
56734 }
56735
56736
56737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
56738   int jresult ;
56739   int result;
56740
56741   {
56742     try {
56743       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
56744     } catch (std::out_of_range& e) {
56745       {
56746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (std::exception& e) {
56749       {
56750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758   jresult = (int)result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
56764   int jresult ;
56765   int result;
56766
56767   {
56768     try {
56769       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
56770     } catch (std::out_of_range& e) {
56771       {
56772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56773       };
56774     } catch (std::exception& e) {
56775       {
56776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56777       };
56778     } catch (...) {
56779       {
56780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56781       };
56782     }
56783   }
56784   jresult = (int)result;
56785   return jresult;
56786 }
56787
56788
56789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
56790   int jresult ;
56791   int result;
56792
56793   {
56794     try {
56795       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
56796     } catch (std::out_of_range& e) {
56797       {
56798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56799       };
56800     } catch (std::exception& e) {
56801       {
56802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56803       };
56804     } catch (...) {
56805       {
56806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56807       };
56808     }
56809   }
56810   jresult = (int)result;
56811   return jresult;
56812 }
56813
56814
56815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
56816   int jresult ;
56817   int result;
56818
56819   {
56820     try {
56821       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
56822     } catch (std::out_of_range& e) {
56823       {
56824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56825       };
56826     } catch (std::exception& e) {
56827       {
56828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56829       };
56830     } catch (...) {
56831       {
56832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56833       };
56834     }
56835   }
56836   jresult = (int)result;
56837   return jresult;
56838 }
56839
56840
56841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
56842   int jresult ;
56843   int result;
56844
56845   {
56846     try {
56847       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
56848     } catch (std::out_of_range& e) {
56849       {
56850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56851       };
56852     } catch (std::exception& e) {
56853       {
56854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56855       };
56856     } catch (...) {
56857       {
56858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56859       };
56860     }
56861   }
56862   jresult = (int)result;
56863   return jresult;
56864 }
56865
56866
56867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
56868   int jresult ;
56869   int result;
56870
56871   {
56872     try {
56873       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
56874     } catch (std::out_of_range& e) {
56875       {
56876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56877       };
56878     } catch (std::exception& e) {
56879       {
56880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56881       };
56882     } catch (...) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56885       };
56886     }
56887   }
56888   jresult = (int)result;
56889   return jresult;
56890 }
56891
56892
56893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
56894   int jresult ;
56895   int result;
56896
56897   {
56898     try {
56899       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
56900     } catch (std::out_of_range& e) {
56901       {
56902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (std::exception& e) {
56905       {
56906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56907       };
56908     } catch (...) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56911       };
56912     }
56913   }
56914   jresult = (int)result;
56915   return jresult;
56916 }
56917
56918
56919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
56920   int jresult ;
56921   int result;
56922
56923   {
56924     try {
56925       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
56926     } catch (std::out_of_range& e) {
56927       {
56928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (std::exception& e) {
56931       {
56932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56933       };
56934     } catch (...) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56937       };
56938     }
56939   }
56940   jresult = (int)result;
56941   return jresult;
56942 }
56943
56944
56945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
56946   int jresult ;
56947   int result;
56948
56949   {
56950     try {
56951       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
56952     } catch (std::out_of_range& e) {
56953       {
56954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (std::exception& e) {
56957       {
56958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (...) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56963       };
56964     }
56965   }
56966   jresult = (int)result;
56967   return jresult;
56968 }
56969
56970
56971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
56972   int jresult ;
56973   int result;
56974
56975   {
56976     try {
56977       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
56978     } catch (std::out_of_range& e) {
56979       {
56980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56981       };
56982     } catch (std::exception& e) {
56983       {
56984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56985       };
56986     } catch (...) {
56987       {
56988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56989       };
56990     }
56991   }
56992   jresult = (int)result;
56993   return jresult;
56994 }
56995
56996
56997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
56998   int jresult ;
56999   int result;
57000
57001   {
57002     try {
57003       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
57004     } catch (std::out_of_range& e) {
57005       {
57006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (std::exception& e) {
57009       {
57010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57015       };
57016     }
57017   }
57018   jresult = (int)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
57024   void * jresult ;
57025   Dali::Toolkit::Control result;
57026
57027   {
57028     try {
57029       result = Dali::Toolkit::Internal::Control::New();
57030     } catch (std::out_of_range& e) {
57031       {
57032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57033       };
57034     } catch (std::exception& e) {
57035       {
57036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57037       };
57038     } catch (...) {
57039       {
57040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57041       };
57042     }
57043   }
57044   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
57045   return jresult;
57046 }
57047
57048
57049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
57050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57051   std::string *arg2 = 0 ;
57052
57053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57054   if (!jarg2) {
57055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57056     return ;
57057   }
57058   std::string arg2_str(jarg2);
57059   arg2 = &arg2_str;
57060   {
57061     try {
57062       (arg1)->SetStyleName((std::string const &)*arg2);
57063     } catch (std::out_of_range& e) {
57064       {
57065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57066       };
57067     } catch (std::exception& e) {
57068       {
57069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57070       };
57071     } catch (...) {
57072       {
57073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57074       };
57075     }
57076   }
57077
57078   //argout typemap for const std::string&
57079
57080 }
57081
57082
57083 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
57084   char * jresult ;
57085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57086   std::string *result = 0 ;
57087
57088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57089   {
57090     try {
57091       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
57092     } catch (std::out_of_range& e) {
57093       {
57094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57095       };
57096     } catch (std::exception& e) {
57097       {
57098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57099       };
57100     } catch (...) {
57101       {
57102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57103       };
57104     }
57105   }
57106   jresult = SWIG_csharp_string_callback(result->c_str());
57107   return jresult;
57108 }
57109
57110
57111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
57112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57113   Dali::Vector4 *arg2 = 0 ;
57114
57115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57116   arg2 = (Dali::Vector4 *)jarg2;
57117   if (!arg2) {
57118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
57119     return ;
57120   }
57121   {
57122     try {
57123       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
57124     } catch (std::out_of_range& e) {
57125       {
57126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57127       };
57128     } catch (std::exception& e) {
57129       {
57130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57131       };
57132     } catch (...) {
57133       {
57134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57135       };
57136     }
57137   }
57138 }
57139
57140
57141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
57142   void * jresult ;
57143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57144   Dali::Vector4 result;
57145
57146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57147   {
57148     try {
57149       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
57150     } catch (std::out_of_range& e) {
57151       {
57152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57153       };
57154     } catch (std::exception& e) {
57155       {
57156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57157       };
57158     } catch (...) {
57159       {
57160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57161       };
57162     }
57163   }
57164   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
57165   return jresult;
57166 }
57167
57168
57169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
57170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57171   Dali::Image arg2 ;
57172   Dali::Image *argp2 ;
57173
57174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57175   argp2 = (Dali::Image *)jarg2;
57176   if (!argp2) {
57177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
57178     return ;
57179   }
57180   arg2 = *argp2;
57181   {
57182     try {
57183       (arg1)->SetBackgroundImage(arg2);
57184     } catch (std::out_of_range& e) {
57185       {
57186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57187       };
57188     } catch (std::exception& e) {
57189       {
57190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57191       };
57192     } catch (...) {
57193       {
57194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57195       };
57196     }
57197   }
57198 }
57199
57200
57201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
57202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57203   Dali::Property::Map *arg2 = 0 ;
57204
57205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57206   arg2 = (Dali::Property::Map *)jarg2;
57207   if (!arg2) {
57208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57209     return ;
57210   }
57211   {
57212     try {
57213       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
57214     } catch (std::out_of_range& e) {
57215       {
57216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57217       };
57218     } catch (std::exception& e) {
57219       {
57220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57221       };
57222     } catch (...) {
57223       {
57224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57225       };
57226     }
57227   }
57228 }
57229
57230
57231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
57232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57233
57234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57235   {
57236     try {
57237       (arg1)->ClearBackground();
57238     } catch (std::out_of_range& e) {
57239       {
57240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57241       };
57242     } catch (std::exception& e) {
57243       {
57244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57245       };
57246     } catch (...) {
57247       {
57248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57249       };
57250     }
57251   }
57252 }
57253
57254
57255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
57256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57257   Dali::Gesture::Type arg2 ;
57258
57259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57260   arg2 = (Dali::Gesture::Type)jarg2;
57261   {
57262     try {
57263       (arg1)->EnableGestureDetection(arg2);
57264     } catch (std::out_of_range& e) {
57265       {
57266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57267       };
57268     } catch (std::exception& e) {
57269       {
57270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57271       };
57272     } catch (...) {
57273       {
57274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57275       };
57276     }
57277   }
57278 }
57279
57280
57281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
57282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57283   Dali::Gesture::Type arg2 ;
57284
57285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57286   arg2 = (Dali::Gesture::Type)jarg2;
57287   {
57288     try {
57289       (arg1)->DisableGestureDetection(arg2);
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57297       };
57298     } catch (...) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57301       };
57302     }
57303   }
57304 }
57305
57306
57307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
57308   void * jresult ;
57309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57310   Dali::PinchGestureDetector result;
57311
57312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57313   {
57314     try {
57315       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
57316     } catch (std::out_of_range& e) {
57317       {
57318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57319       };
57320     } catch (std::exception& e) {
57321       {
57322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57323       };
57324     } catch (...) {
57325       {
57326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57327       };
57328     }
57329   }
57330   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
57331   return jresult;
57332 }
57333
57334
57335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
57336   void * jresult ;
57337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57338   Dali::PanGestureDetector result;
57339
57340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57341   {
57342     try {
57343       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
57344     } catch (std::out_of_range& e) {
57345       {
57346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57347       };
57348     } catch (std::exception& e) {
57349       {
57350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57351       };
57352     } catch (...) {
57353       {
57354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57355       };
57356     }
57357   }
57358   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
57359   return jresult;
57360 }
57361
57362
57363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
57364   void * jresult ;
57365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57366   Dali::TapGestureDetector result;
57367
57368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57369   {
57370     try {
57371       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
57372     } catch (std::out_of_range& e) {
57373       {
57374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57375       };
57376     } catch (std::exception& e) {
57377       {
57378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57379       };
57380     } catch (...) {
57381       {
57382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57383       };
57384     }
57385   }
57386   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
57387   return jresult;
57388 }
57389
57390
57391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
57392   void * jresult ;
57393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57394   Dali::LongPressGestureDetector result;
57395
57396   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57397   {
57398     try {
57399       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
57400     } catch (std::out_of_range& e) {
57401       {
57402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57403       };
57404     } catch (std::exception& e) {
57405       {
57406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57407       };
57408     } catch (...) {
57409       {
57410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57411       };
57412     }
57413   }
57414   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
57415   return jresult;
57416 }
57417
57418
57419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
57420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57421   bool arg2 ;
57422
57423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57424   arg2 = jarg2 ? true : false;
57425   {
57426     try {
57427       (arg1)->SetKeyboardNavigationSupport(arg2);
57428     } catch (std::out_of_range& e) {
57429       {
57430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57431       };
57432     } catch (std::exception& e) {
57433       {
57434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57435       };
57436     } catch (...) {
57437       {
57438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57439       };
57440     }
57441   }
57442 }
57443
57444
57445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
57446   unsigned int jresult ;
57447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57448   bool result;
57449
57450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57451   {
57452     try {
57453       result = (bool)(arg1)->IsKeyboardNavigationSupported();
57454     } catch (std::out_of_range& e) {
57455       {
57456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (std::exception& e) {
57459       {
57460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (...) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57465       };
57466     }
57467   }
57468   jresult = result;
57469   return jresult;
57470 }
57471
57472
57473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
57474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57475
57476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57477   {
57478     try {
57479       (arg1)->SetKeyInputFocus();
57480     } catch (std::out_of_range& e) {
57481       {
57482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57483       };
57484     } catch (std::exception& e) {
57485       {
57486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57487       };
57488     } catch (...) {
57489       {
57490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57491       };
57492     }
57493   }
57494 }
57495
57496
57497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
57498   unsigned int jresult ;
57499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57500   bool result;
57501
57502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57503   {
57504     try {
57505       result = (bool)(arg1)->HasKeyInputFocus();
57506     } catch (std::out_of_range& e) {
57507       {
57508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57509       };
57510     } catch (std::exception& e) {
57511       {
57512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57513       };
57514     } catch (...) {
57515       {
57516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57517       };
57518     }
57519   }
57520   jresult = result;
57521   return jresult;
57522 }
57523
57524
57525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
57526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57527
57528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57529   {
57530     try {
57531       (arg1)->ClearKeyInputFocus();
57532     } catch (std::out_of_range& e) {
57533       {
57534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57535       };
57536     } catch (std::exception& e) {
57537       {
57538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57539       };
57540     } catch (...) {
57541       {
57542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57543       };
57544     }
57545   }
57546 }
57547
57548
57549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
57550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57551   bool arg2 ;
57552
57553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57554   arg2 = jarg2 ? true : false;
57555   {
57556     try {
57557       (arg1)->SetAsKeyboardFocusGroup(arg2);
57558     } catch (std::out_of_range& e) {
57559       {
57560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57561       };
57562     } catch (std::exception& e) {
57563       {
57564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57565       };
57566     } catch (...) {
57567       {
57568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57569       };
57570     }
57571   }
57572 }
57573
57574
57575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
57576   unsigned int jresult ;
57577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57578   bool result;
57579
57580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57581   {
57582     try {
57583       result = (bool)(arg1)->IsKeyboardFocusGroup();
57584     } catch (std::out_of_range& e) {
57585       {
57586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57587       };
57588     } catch (std::exception& e) {
57589       {
57590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57591       };
57592     } catch (...) {
57593       {
57594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57595       };
57596     }
57597   }
57598   jresult = result;
57599   return jresult;
57600 }
57601
57602
57603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
57604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57605
57606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57607   {
57608     try {
57609       (arg1)->AccessibilityActivate();
57610     } catch (std::out_of_range& e) {
57611       {
57612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57613       };
57614     } catch (std::exception& e) {
57615       {
57616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57617       };
57618     } catch (...) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57621       };
57622     }
57623   }
57624 }
57625
57626
57627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
57628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57629
57630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57631   {
57632     try {
57633       (arg1)->KeyboardEnter();
57634     } catch (std::out_of_range& e) {
57635       {
57636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57637       };
57638     } catch (std::exception& e) {
57639       {
57640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57641       };
57642     } catch (...) {
57643       {
57644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57645       };
57646     }
57647   }
57648 }
57649
57650
57651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
57652   void * jresult ;
57653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57654   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
57655
57656   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57657   {
57658     try {
57659       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
57660     } catch (std::out_of_range& e) {
57661       {
57662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57663       };
57664     } catch (std::exception& e) {
57665       {
57666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57667       };
57668     } catch (...) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57671       };
57672     }
57673   }
57674   jresult = (void *)result;
57675   return jresult;
57676 }
57677
57678
57679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
57680   void * jresult ;
57681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57682   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
57683
57684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57685   {
57686     try {
57687       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
57688     } catch (std::out_of_range& e) {
57689       {
57690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57691       };
57692     } catch (std::exception& e) {
57693       {
57694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (...) {
57697       {
57698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57699       };
57700     }
57701   }
57702   jresult = (void *)result;
57703   return jresult;
57704 }
57705
57706
57707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
57708   void * jresult ;
57709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57710   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
57711
57712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57713   {
57714     try {
57715       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
57716     } catch (std::out_of_range& e) {
57717       {
57718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57719       };
57720     } catch (std::exception& e) {
57721       {
57722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57723       };
57724     } catch (...) {
57725       {
57726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57727       };
57728     }
57729   }
57730   jresult = (void *)result;
57731   return jresult;
57732 }
57733
57734
57735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
57736   unsigned int jresult ;
57737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57738   Dali::KeyEvent *arg2 = 0 ;
57739   bool result;
57740
57741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57742   arg2 = (Dali::KeyEvent *)jarg2;
57743   if (!arg2) {
57744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
57745     return 0;
57746   }
57747   {
57748     try {
57749       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
57750     } catch (std::out_of_range& e) {
57751       {
57752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (std::exception& e) {
57755       {
57756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (...) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57761       };
57762     }
57763   }
57764   jresult = result;
57765   return jresult;
57766 }
57767
57768
57769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
57770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57771   int arg2 ;
57772   SwigDirector_ViewImpl *darg = 0;
57773
57774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57775   arg2 = (int)jarg2;
57776   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57777   {
57778     try {
57779       (darg)->OnStageConnection(arg2);
57780     } catch (std::out_of_range& e) {
57781       {
57782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57783       };
57784     } catch (std::exception& e) {
57785       {
57786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57787       };
57788     } catch (...) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57791       };
57792     }
57793   }
57794 }
57795
57796
57797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
57798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57799   int arg2 ;
57800   SwigDirector_ViewImpl *darg = 0;
57801
57802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57803   arg2 = (int)jarg2;
57804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57805   {
57806     try {
57807       (darg)->OnStageConnectionSwigPublic(arg2);
57808     } catch (std::out_of_range& e) {
57809       {
57810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57811       };
57812     } catch (std::exception& e) {
57813       {
57814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (...) {
57817       {
57818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57819       };
57820     }
57821   }
57822 }
57823
57824
57825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
57826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57827   SwigDirector_ViewImpl *darg = 0;
57828
57829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57830   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57831   {
57832     try {
57833       (darg)->OnStageDisconnection();
57834     } catch (std::out_of_range& e) {
57835       {
57836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57837       };
57838     } catch (std::exception& e) {
57839       {
57840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57841       };
57842     } catch (...) {
57843       {
57844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57845       };
57846     }
57847   }
57848 }
57849
57850
57851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
57852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57853   SwigDirector_ViewImpl *darg = 0;
57854
57855   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57857   {
57858     try {
57859       (darg)->OnStageDisconnectionSwigPublic();
57860     } catch (std::out_of_range& e) {
57861       {
57862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57863       };
57864     } catch (std::exception& e) {
57865       {
57866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57867       };
57868     } catch (...) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57871       };
57872     }
57873   }
57874 }
57875
57876
57877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
57878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57879   Dali::Actor *arg2 = 0 ;
57880   SwigDirector_ViewImpl *darg = 0;
57881
57882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57883   arg2 = (Dali::Actor *)jarg2;
57884   if (!arg2) {
57885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57886     return ;
57887   }
57888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57889   {
57890     try {
57891       (darg)->OnChildAdd(*arg2);
57892     } catch (std::out_of_range& e) {
57893       {
57894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57895       };
57896     } catch (std::exception& e) {
57897       {
57898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57899       };
57900     } catch (...) {
57901       {
57902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57903       };
57904     }
57905   }
57906 }
57907
57908
57909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57911   Dali::Actor *arg2 = 0 ;
57912   SwigDirector_ViewImpl *darg = 0;
57913
57914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57915   arg2 = (Dali::Actor *)jarg2;
57916   if (!arg2) {
57917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57918     return ;
57919   }
57920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57921   {
57922     try {
57923       (darg)->OnChildAddSwigPublic(*arg2);
57924     } catch (std::out_of_range& e) {
57925       {
57926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57927       };
57928     } catch (std::exception& e) {
57929       {
57930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57931       };
57932     } catch (...) {
57933       {
57934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57935       };
57936     }
57937   }
57938 }
57939
57940
57941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
57942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57943   Dali::Actor *arg2 = 0 ;
57944   SwigDirector_ViewImpl *darg = 0;
57945
57946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57947   arg2 = (Dali::Actor *)jarg2;
57948   if (!arg2) {
57949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57950     return ;
57951   }
57952   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57953   {
57954     try {
57955       (darg)->OnChildRemove(*arg2);
57956     } catch (std::out_of_range& e) {
57957       {
57958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57959       };
57960     } catch (std::exception& e) {
57961       {
57962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57963       };
57964     } catch (...) {
57965       {
57966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57967       };
57968     }
57969   }
57970 }
57971
57972
57973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57975   Dali::Actor *arg2 = 0 ;
57976   SwigDirector_ViewImpl *darg = 0;
57977
57978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57979   arg2 = (Dali::Actor *)jarg2;
57980   if (!arg2) {
57981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57982     return ;
57983   }
57984   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57985   {
57986     try {
57987       (darg)->OnChildRemoveSwigPublic(*arg2);
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57999       };
58000     }
58001   }
58002 }
58003
58004
58005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
58006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58007   Dali::Property::Index arg2 ;
58008   Dali::Property::Value arg3 ;
58009   Dali::Property::Value *argp3 ;
58010   SwigDirector_ViewImpl *darg = 0;
58011
58012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58013   arg2 = (Dali::Property::Index)jarg2;
58014   argp3 = (Dali::Property::Value *)jarg3;
58015   if (!argp3) {
58016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
58017     return ;
58018   }
58019   arg3 = *argp3;
58020   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58021   {
58022     try {
58023       (darg)->OnPropertySet(arg2,arg3);
58024     } catch (std::out_of_range& e) {
58025       {
58026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58027       };
58028     } catch (std::exception& e) {
58029       {
58030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58031       };
58032     } catch (...) {
58033       {
58034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58035       };
58036     }
58037   }
58038 }
58039
58040
58041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
58042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58043   Dali::Property::Index arg2 ;
58044   Dali::Property::Value arg3 ;
58045   Dali::Property::Value *argp3 ;
58046   SwigDirector_ViewImpl *darg = 0;
58047
58048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58049   arg2 = (Dali::Property::Index)jarg2;
58050   argp3 = (Dali::Property::Value *)jarg3;
58051   if (!argp3) {
58052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
58053     return ;
58054   }
58055   arg3 = *argp3;
58056   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58057   {
58058     try {
58059       (darg)->OnPropertySetSwigPublic(arg2,arg3);
58060     } catch (std::out_of_range& e) {
58061       {
58062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58063       };
58064     } catch (std::exception& e) {
58065       {
58066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58067       };
58068     } catch (...) {
58069       {
58070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58071       };
58072     }
58073   }
58074 }
58075
58076
58077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
58078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58079   Dali::Vector3 *arg2 = 0 ;
58080   SwigDirector_ViewImpl *darg = 0;
58081
58082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58083   arg2 = (Dali::Vector3 *)jarg2;
58084   if (!arg2) {
58085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58086     return ;
58087   }
58088   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58089   {
58090     try {
58091       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
58092     } catch (std::out_of_range& e) {
58093       {
58094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58095       };
58096     } catch (std::exception& e) {
58097       {
58098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58099       };
58100     } catch (...) {
58101       {
58102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58103       };
58104     }
58105   }
58106 }
58107
58108
58109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58111   Dali::Vector3 *arg2 = 0 ;
58112   SwigDirector_ViewImpl *darg = 0;
58113
58114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58115   arg2 = (Dali::Vector3 *)jarg2;
58116   if (!arg2) {
58117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58118     return ;
58119   }
58120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58121   {
58122     try {
58123       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
58124     } catch (std::out_of_range& e) {
58125       {
58126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58127       };
58128     } catch (std::exception& e) {
58129       {
58130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58131       };
58132     } catch (...) {
58133       {
58134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58135       };
58136     }
58137   }
58138 }
58139
58140
58141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
58142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58143   Dali::Animation *arg2 = 0 ;
58144   Dali::Vector3 *arg3 = 0 ;
58145   SwigDirector_ViewImpl *darg = 0;
58146
58147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58148   arg2 = (Dali::Animation *)jarg2;
58149   if (!arg2) {
58150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
58151     return ;
58152   }
58153   arg3 = (Dali::Vector3 *)jarg3;
58154   if (!arg3) {
58155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58156     return ;
58157   }
58158   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58159   {
58160     try {
58161       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
58162     } catch (std::out_of_range& e) {
58163       {
58164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58165       };
58166     } catch (std::exception& e) {
58167       {
58168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58169       };
58170     } catch (...) {
58171       {
58172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58173       };
58174     }
58175   }
58176 }
58177
58178
58179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58181   Dali::Animation *arg2 = 0 ;
58182   Dali::Vector3 *arg3 = 0 ;
58183   SwigDirector_ViewImpl *darg = 0;
58184
58185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58186   arg2 = (Dali::Animation *)jarg2;
58187   if (!arg2) {
58188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
58189     return ;
58190   }
58191   arg3 = (Dali::Vector3 *)jarg3;
58192   if (!arg3) {
58193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58194     return ;
58195   }
58196   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58197   {
58198     try {
58199       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
58200     } catch (std::out_of_range& e) {
58201       {
58202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58203       };
58204     } catch (std::exception& e) {
58205       {
58206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58207       };
58208     } catch (...) {
58209       {
58210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58211       };
58212     }
58213   }
58214 }
58215
58216
58217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
58218   unsigned int jresult ;
58219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58220   Dali::TouchEvent *arg2 = 0 ;
58221   SwigDirector_ViewImpl *darg = 0;
58222   bool result;
58223
58224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58225   arg2 = (Dali::TouchEvent *)jarg2;
58226   if (!arg2) {
58227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58228     return 0;
58229   }
58230   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58231   {
58232     try {
58233       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
58234     } catch (std::out_of_range& e) {
58235       {
58236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58237       };
58238     } catch (std::exception& e) {
58239       {
58240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58241       };
58242     } catch (...) {
58243       {
58244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58245       };
58246     }
58247   }
58248   jresult = result;
58249   return jresult;
58250 }
58251
58252
58253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58254   unsigned int jresult ;
58255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58256   Dali::TouchEvent *arg2 = 0 ;
58257   SwigDirector_ViewImpl *darg = 0;
58258   bool result;
58259
58260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58261   arg2 = (Dali::TouchEvent *)jarg2;
58262   if (!arg2) {
58263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58264     return 0;
58265   }
58266   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58267   {
58268     try {
58269       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
58270     } catch (std::out_of_range& e) {
58271       {
58272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58273       };
58274     } catch (std::exception& e) {
58275       {
58276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58277       };
58278     } catch (...) {
58279       {
58280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58281       };
58282     }
58283   }
58284   jresult = result;
58285   return jresult;
58286 }
58287
58288
58289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
58290   unsigned int jresult ;
58291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58292   Dali::HoverEvent *arg2 = 0 ;
58293   SwigDirector_ViewImpl *darg = 0;
58294   bool result;
58295
58296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58297   arg2 = (Dali::HoverEvent *)jarg2;
58298   if (!arg2) {
58299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
58300     return 0;
58301   }
58302   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58303   {
58304     try {
58305       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
58306     } catch (std::out_of_range& e) {
58307       {
58308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58309       };
58310     } catch (std::exception& e) {
58311       {
58312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58313       };
58314     } catch (...) {
58315       {
58316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58317       };
58318     }
58319   }
58320   jresult = result;
58321   return jresult;
58322 }
58323
58324
58325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58326   unsigned int jresult ;
58327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58328   Dali::HoverEvent *arg2 = 0 ;
58329   SwigDirector_ViewImpl *darg = 0;
58330   bool result;
58331
58332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58333   arg2 = (Dali::HoverEvent *)jarg2;
58334   if (!arg2) {
58335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
58336     return 0;
58337   }
58338   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58339   {
58340     try {
58341       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
58342     } catch (std::out_of_range& e) {
58343       {
58344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58345       };
58346     } catch (std::exception& e) {
58347       {
58348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58349       };
58350     } catch (...) {
58351       {
58352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58353       };
58354     }
58355   }
58356   jresult = result;
58357   return jresult;
58358 }
58359
58360
58361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
58362   unsigned int jresult ;
58363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58364   Dali::KeyEvent *arg2 = 0 ;
58365   SwigDirector_ViewImpl *darg = 0;
58366   bool result;
58367
58368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58369   arg2 = (Dali::KeyEvent *)jarg2;
58370   if (!arg2) {
58371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58372     return 0;
58373   }
58374   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58375   {
58376     try {
58377       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
58378     } catch (std::out_of_range& e) {
58379       {
58380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58381       };
58382     } catch (std::exception& e) {
58383       {
58384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (...) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58389       };
58390     }
58391   }
58392   jresult = result;
58393   return jresult;
58394 }
58395
58396
58397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58398   unsigned int jresult ;
58399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58400   Dali::KeyEvent *arg2 = 0 ;
58401   SwigDirector_ViewImpl *darg = 0;
58402   bool result;
58403
58404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58405   arg2 = (Dali::KeyEvent *)jarg2;
58406   if (!arg2) {
58407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58408     return 0;
58409   }
58410   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58411   {
58412     try {
58413       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
58414     } catch (std::out_of_range& e) {
58415       {
58416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58417       };
58418     } catch (std::exception& e) {
58419       {
58420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58421       };
58422     } catch (...) {
58423       {
58424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58425       };
58426     }
58427   }
58428   jresult = result;
58429   return jresult;
58430 }
58431
58432
58433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
58434   unsigned int jresult ;
58435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58436   Dali::WheelEvent *arg2 = 0 ;
58437   SwigDirector_ViewImpl *darg = 0;
58438   bool result;
58439
58440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58441   arg2 = (Dali::WheelEvent *)jarg2;
58442   if (!arg2) {
58443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
58444     return 0;
58445   }
58446   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58447   {
58448     try {
58449       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
58450     } catch (std::out_of_range& e) {
58451       {
58452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58453       };
58454     } catch (std::exception& e) {
58455       {
58456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58457       };
58458     } catch (...) {
58459       {
58460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58461       };
58462     }
58463   }
58464   jresult = result;
58465   return jresult;
58466 }
58467
58468
58469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58470   unsigned int jresult ;
58471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58472   Dali::WheelEvent *arg2 = 0 ;
58473   SwigDirector_ViewImpl *darg = 0;
58474   bool result;
58475
58476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58477   arg2 = (Dali::WheelEvent *)jarg2;
58478   if (!arg2) {
58479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
58480     return 0;
58481   }
58482   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58483   {
58484     try {
58485       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
58486     } catch (std::out_of_range& e) {
58487       {
58488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58489       };
58490     } catch (std::exception& e) {
58491       {
58492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58493       };
58494     } catch (...) {
58495       {
58496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58497       };
58498     }
58499   }
58500   jresult = result;
58501   return jresult;
58502 }
58503
58504
58505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
58506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58507   Dali::Vector2 *arg2 = 0 ;
58508   Dali::RelayoutContainer *arg3 = 0 ;
58509   SwigDirector_ViewImpl *darg = 0;
58510
58511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58512   arg2 = (Dali::Vector2 *)jarg2;
58513   if (!arg2) {
58514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
58515     return ;
58516   }
58517   arg3 = (Dali::RelayoutContainer *)jarg3;
58518   if (!arg3) {
58519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
58520     return ;
58521   }
58522   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58523   {
58524     try {
58525       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
58526     } catch (std::out_of_range& e) {
58527       {
58528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58529       };
58530     } catch (std::exception& e) {
58531       {
58532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58533       };
58534     } catch (...) {
58535       {
58536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58537       };
58538     }
58539   }
58540 }
58541
58542
58543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58545   Dali::Vector2 *arg2 = 0 ;
58546   Dali::RelayoutContainer *arg3 = 0 ;
58547   SwigDirector_ViewImpl *darg = 0;
58548
58549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58550   arg2 = (Dali::Vector2 *)jarg2;
58551   if (!arg2) {
58552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
58553     return ;
58554   }
58555   arg3 = (Dali::RelayoutContainer *)jarg3;
58556   if (!arg3) {
58557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
58558     return ;
58559   }
58560   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58561   {
58562     try {
58563       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
58564     } catch (std::out_of_range& e) {
58565       {
58566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58567       };
58568     } catch (std::exception& e) {
58569       {
58570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (...) {
58573       {
58574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58575       };
58576     }
58577   }
58578 }
58579
58580
58581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
58582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58583   Dali::ResizePolicy::Type arg2 ;
58584   Dali::Dimension::Type arg3 ;
58585   SwigDirector_ViewImpl *darg = 0;
58586
58587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58588   arg2 = (Dali::ResizePolicy::Type)jarg2;
58589   arg3 = (Dali::Dimension::Type)jarg3;
58590   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58591   {
58592     try {
58593       (darg)->OnSetResizePolicy(arg2,arg3);
58594     } catch (std::out_of_range& e) {
58595       {
58596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58597       };
58598     } catch (std::exception& e) {
58599       {
58600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58601       };
58602     } catch (...) {
58603       {
58604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58605       };
58606     }
58607   }
58608 }
58609
58610
58611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
58612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58613   Dali::ResizePolicy::Type arg2 ;
58614   Dali::Dimension::Type arg3 ;
58615   SwigDirector_ViewImpl *darg = 0;
58616
58617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58618   arg2 = (Dali::ResizePolicy::Type)jarg2;
58619   arg3 = (Dali::Dimension::Type)jarg3;
58620   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58621   {
58622     try {
58623       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
58624     } catch (std::out_of_range& e) {
58625       {
58626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58627       };
58628     } catch (std::exception& e) {
58629       {
58630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58631       };
58632     } catch (...) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58635       };
58636     }
58637   }
58638 }
58639
58640
58641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
58642   void * jresult ;
58643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58644   SwigDirector_ViewImpl *darg = 0;
58645   Dali::Vector3 result;
58646
58647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58648   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58649   {
58650     try {
58651       result = (darg)->GetNaturalSize();
58652     } catch (std::out_of_range& e) {
58653       {
58654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58655       };
58656     } catch (std::exception& e) {
58657       {
58658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58659       };
58660     } catch (...) {
58661       {
58662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58663       };
58664     }
58665   }
58666   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
58667   return jresult;
58668 }
58669
58670
58671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
58672   void * jresult ;
58673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58674   SwigDirector_ViewImpl *darg = 0;
58675   Dali::Vector3 result;
58676
58677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58678   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58679   {
58680     try {
58681       result = (darg)->GetNaturalSizeSwigPublic();
58682     } catch (std::out_of_range& e) {
58683       {
58684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58685       };
58686     } catch (std::exception& e) {
58687       {
58688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58689       };
58690     } catch (...) {
58691       {
58692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58693       };
58694     }
58695   }
58696   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
58697   return jresult;
58698 }
58699
58700
58701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
58702   float jresult ;
58703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58704   Dali::Actor *arg2 = 0 ;
58705   Dali::Dimension::Type arg3 ;
58706   SwigDirector_ViewImpl *darg = 0;
58707   float result;
58708
58709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58710   arg2 = (Dali::Actor *)jarg2;
58711   if (!arg2) {
58712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
58713     return 0;
58714   }
58715   arg3 = (Dali::Dimension::Type)jarg3;
58716   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58717   {
58718     try {
58719       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
58720     } catch (std::out_of_range& e) {
58721       {
58722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58723       };
58724     } catch (std::exception& e) {
58725       {
58726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58727       };
58728     } catch (...) {
58729       {
58730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58731       };
58732     }
58733   }
58734   jresult = result;
58735   return jresult;
58736 }
58737
58738
58739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
58740   float jresult ;
58741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58742   Dali::Actor *arg2 = 0 ;
58743   Dali::Dimension::Type arg3 ;
58744   SwigDirector_ViewImpl *darg = 0;
58745   float result;
58746
58747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58748   arg2 = (Dali::Actor *)jarg2;
58749   if (!arg2) {
58750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
58751     return 0;
58752   }
58753   arg3 = (Dali::Dimension::Type)jarg3;
58754   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58755   {
58756     try {
58757       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58765       };
58766     } catch (...) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58769       };
58770     }
58771   }
58772   jresult = result;
58773   return jresult;
58774 }
58775
58776
58777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
58778   float jresult ;
58779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58780   float arg2 ;
58781   SwigDirector_ViewImpl *darg = 0;
58782   float result;
58783
58784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58785   arg2 = (float)jarg2;
58786   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58787   {
58788     try {
58789       result = (float)(darg)->GetHeightForWidth(arg2);
58790     } catch (std::out_of_range& e) {
58791       {
58792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58793       };
58794     } catch (std::exception& e) {
58795       {
58796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58797       };
58798     } catch (...) {
58799       {
58800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58801       };
58802     }
58803   }
58804   jresult = result;
58805   return jresult;
58806 }
58807
58808
58809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
58810   float jresult ;
58811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58812   float arg2 ;
58813   SwigDirector_ViewImpl *darg = 0;
58814   float result;
58815
58816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58817   arg2 = (float)jarg2;
58818   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58819   {
58820     try {
58821       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
58822     } catch (std::out_of_range& e) {
58823       {
58824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (std::exception& e) {
58827       {
58828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58829       };
58830     } catch (...) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58833       };
58834     }
58835   }
58836   jresult = result;
58837   return jresult;
58838 }
58839
58840
58841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
58842   float jresult ;
58843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58844   float arg2 ;
58845   SwigDirector_ViewImpl *darg = 0;
58846   float result;
58847
58848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58849   arg2 = (float)jarg2;
58850   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58851   {
58852     try {
58853       result = (float)(darg)->GetWidthForHeight(arg2);
58854     } catch (std::out_of_range& e) {
58855       {
58856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58857       };
58858     } catch (std::exception& e) {
58859       {
58860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58861       };
58862     } catch (...) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58865       };
58866     }
58867   }
58868   jresult = result;
58869   return jresult;
58870 }
58871
58872
58873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
58874   float jresult ;
58875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58876   float arg2 ;
58877   SwigDirector_ViewImpl *darg = 0;
58878   float result;
58879
58880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58881   arg2 = (float)jarg2;
58882   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58883   {
58884     try {
58885       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
58886     } catch (std::out_of_range& e) {
58887       {
58888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58889       };
58890     } catch (std::exception& e) {
58891       {
58892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58893       };
58894     } catch (...) {
58895       {
58896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58897       };
58898     }
58899   }
58900   jresult = result;
58901   return jresult;
58902 }
58903
58904
58905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
58906   unsigned int jresult ;
58907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58908   Dali::Dimension::Type arg2 ;
58909   SwigDirector_ViewImpl *darg = 0;
58910   bool result;
58911
58912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58913   arg2 = (Dali::Dimension::Type)jarg2;
58914   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58915   {
58916     try {
58917       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
58918     } catch (std::out_of_range& e) {
58919       {
58920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58921       };
58922     } catch (std::exception& e) {
58923       {
58924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (...) {
58927       {
58928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58929       };
58930     }
58931   }
58932   jresult = result;
58933   return jresult;
58934 }
58935
58936
58937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
58938   unsigned int jresult ;
58939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58940   Dali::Dimension::Type arg2 ;
58941   SwigDirector_ViewImpl *darg = 0;
58942   bool result;
58943
58944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58945   arg2 = (Dali::Dimension::Type)jarg2;
58946   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58947   {
58948     try {
58949       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
58950     } catch (std::out_of_range& e) {
58951       {
58952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58953       };
58954     } catch (std::exception& e) {
58955       {
58956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (...) {
58959       {
58960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58961       };
58962     }
58963   }
58964   jresult = result;
58965   return jresult;
58966 }
58967
58968
58969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
58970   unsigned int jresult ;
58971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58972   SwigDirector_ViewImpl *darg = 0;
58973   bool result;
58974
58975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58976   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58977   {
58978     try {
58979       result = (bool)(darg)->RelayoutDependentOnChildren();
58980     } catch (std::out_of_range& e) {
58981       {
58982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58983       };
58984     } catch (std::exception& e) {
58985       {
58986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58987       };
58988     } catch (...) {
58989       {
58990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58991       };
58992     }
58993   }
58994   jresult = result;
58995   return jresult;
58996 }
58997
58998
58999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
59000   unsigned int jresult ;
59001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59002   SwigDirector_ViewImpl *darg = 0;
59003   bool result;
59004
59005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59007   {
59008     try {
59009       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
59010     } catch (std::out_of_range& e) {
59011       {
59012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59013       };
59014     } catch (std::exception& e) {
59015       {
59016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59017       };
59018     } catch (...) {
59019       {
59020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59021       };
59022     }
59023   }
59024   jresult = result;
59025   return jresult;
59026 }
59027
59028
59029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
59030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59031   Dali::Dimension::Type arg2 ;
59032   SwigDirector_ViewImpl *darg = 0;
59033
59034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59035   arg2 = (Dali::Dimension::Type)jarg2;
59036   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59037   {
59038     try {
59039       (darg)->OnCalculateRelayoutSize(arg2);
59040     } catch (std::out_of_range& e) {
59041       {
59042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59043       };
59044     } catch (std::exception& e) {
59045       {
59046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59047       };
59048     } catch (...) {
59049       {
59050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59051       };
59052     }
59053   }
59054 }
59055
59056
59057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
59058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59059   Dali::Dimension::Type arg2 ;
59060   SwigDirector_ViewImpl *darg = 0;
59061
59062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59063   arg2 = (Dali::Dimension::Type)jarg2;
59064   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59065   {
59066     try {
59067       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
59068     } catch (std::out_of_range& e) {
59069       {
59070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59071       };
59072     } catch (std::exception& e) {
59073       {
59074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59075       };
59076     } catch (...) {
59077       {
59078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59079       };
59080     }
59081   }
59082 }
59083
59084
59085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
59086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59087   float arg2 ;
59088   Dali::Dimension::Type arg3 ;
59089   SwigDirector_ViewImpl *darg = 0;
59090
59091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59092   arg2 = (float)jarg2;
59093   arg3 = (Dali::Dimension::Type)jarg3;
59094   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59095   {
59096     try {
59097       (darg)->OnLayoutNegotiated(arg2,arg3);
59098     } catch (std::out_of_range& e) {
59099       {
59100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59101       };
59102     } catch (std::exception& e) {
59103       {
59104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59105       };
59106     } catch (...) {
59107       {
59108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59109       };
59110     }
59111   }
59112 }
59113
59114
59115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
59116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59117   float arg2 ;
59118   Dali::Dimension::Type arg3 ;
59119   SwigDirector_ViewImpl *darg = 0;
59120
59121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59122   arg2 = (float)jarg2;
59123   arg3 = (Dali::Dimension::Type)jarg3;
59124   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59125   {
59126     try {
59127       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
59128     } catch (std::out_of_range& e) {
59129       {
59130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59131       };
59132     } catch (std::exception& e) {
59133       {
59134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59135       };
59136     } catch (...) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59139       };
59140     }
59141   }
59142 }
59143
59144
59145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
59146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59147
59148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59149   {
59150     try {
59151       (arg1)->OnInitialize();
59152     } catch (std::out_of_range& e) {
59153       {
59154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59155       };
59156     } catch (std::exception& e) {
59157       {
59158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59159       };
59160     } catch (...) {
59161       {
59162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59163       };
59164     }
59165   }
59166 }
59167
59168
59169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
59170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59171
59172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59173   {
59174     try {
59175       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
59176     } catch (std::out_of_range& e) {
59177       {
59178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59179       };
59180     } catch (std::exception& e) {
59181       {
59182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59183       };
59184     } catch (...) {
59185       {
59186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59187       };
59188     }
59189   }
59190 }
59191
59192
59193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
59194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59195   Dali::Actor *arg2 = 0 ;
59196
59197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59198   arg2 = (Dali::Actor *)jarg2;
59199   if (!arg2) {
59200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59201     return ;
59202   }
59203   {
59204     try {
59205       (arg1)->OnControlChildAdd(*arg2);
59206     } catch (std::out_of_range& e) {
59207       {
59208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59209       };
59210     } catch (std::exception& e) {
59211       {
59212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59213       };
59214     } catch (...) {
59215       {
59216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59217       };
59218     }
59219   }
59220 }
59221
59222
59223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59225   Dali::Actor *arg2 = 0 ;
59226
59227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59228   arg2 = (Dali::Actor *)jarg2;
59229   if (!arg2) {
59230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59231     return ;
59232   }
59233   {
59234     try {
59235       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
59236     } catch (std::out_of_range& e) {
59237       {
59238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59239       };
59240     } catch (std::exception& e) {
59241       {
59242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59243       };
59244     } catch (...) {
59245       {
59246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59247       };
59248     }
59249   }
59250 }
59251
59252
59253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
59254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59255   Dali::Actor *arg2 = 0 ;
59256
59257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59258   arg2 = (Dali::Actor *)jarg2;
59259   if (!arg2) {
59260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59261     return ;
59262   }
59263   {
59264     try {
59265       (arg1)->OnControlChildRemove(*arg2);
59266     } catch (std::out_of_range& e) {
59267       {
59268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59269       };
59270     } catch (std::exception& e) {
59271       {
59272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59273       };
59274     } catch (...) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59277       };
59278     }
59279   }
59280 }
59281
59282
59283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59285   Dali::Actor *arg2 = 0 ;
59286
59287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59288   arg2 = (Dali::Actor *)jarg2;
59289   if (!arg2) {
59290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59291     return ;
59292   }
59293   {
59294     try {
59295       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
59296     } catch (std::out_of_range& e) {
59297       {
59298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59299       };
59300     } catch (std::exception& e) {
59301       {
59302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59303       };
59304     } catch (...) {
59305       {
59306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59307       };
59308     }
59309   }
59310 }
59311
59312
59313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
59314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59315   Dali::Toolkit::StyleManager arg2 ;
59316   Dali::StyleChange::Type arg3 ;
59317   Dali::Toolkit::StyleManager *argp2 ;
59318
59319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59320   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
59321   if (!argp2) {
59322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
59323     return ;
59324   }
59325   arg2 = *argp2;
59326   arg3 = (Dali::StyleChange::Type)jarg3;
59327   {
59328     try {
59329       (arg1)->OnStyleChange(arg2,arg3);
59330     } catch (std::out_of_range& e) {
59331       {
59332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59333       };
59334     } catch (std::exception& e) {
59335       {
59336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59337       };
59338     } catch (...) {
59339       {
59340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59341       };
59342     }
59343   }
59344 }
59345
59346
59347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
59348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59349   Dali::Toolkit::StyleManager arg2 ;
59350   Dali::StyleChange::Type arg3 ;
59351   Dali::Toolkit::StyleManager *argp2 ;
59352
59353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59354   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
59355   if (!argp2) {
59356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
59357     return ;
59358   }
59359   arg2 = *argp2;
59360   arg3 = (Dali::StyleChange::Type)jarg3;
59361   {
59362     try {
59363       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
59364     } catch (std::out_of_range& e) {
59365       {
59366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59367       };
59368     } catch (std::exception& e) {
59369       {
59370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59371       };
59372     } catch (...) {
59373       {
59374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59375       };
59376     }
59377   }
59378 }
59379
59380
59381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
59382   unsigned int jresult ;
59383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59384   bool result;
59385
59386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59387   {
59388     try {
59389       result = (bool)(arg1)->OnAccessibilityActivated();
59390     } catch (std::out_of_range& e) {
59391       {
59392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59393       };
59394     } catch (std::exception& e) {
59395       {
59396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59397       };
59398     } catch (...) {
59399       {
59400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59401       };
59402     }
59403   }
59404   jresult = result;
59405   return jresult;
59406 }
59407
59408
59409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
59410   unsigned int jresult ;
59411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59412   bool result;
59413
59414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59415   {
59416     try {
59417       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
59418     } catch (std::out_of_range& e) {
59419       {
59420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (std::exception& e) {
59423       {
59424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59429       };
59430     }
59431   }
59432   jresult = result;
59433   return jresult;
59434 }
59435
59436
59437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
59438   unsigned int jresult ;
59439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59440   Dali::PanGesture arg2 ;
59441   Dali::PanGesture *argp2 ;
59442   bool result;
59443
59444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59445   argp2 = (Dali::PanGesture *)jarg2;
59446   if (!argp2) {
59447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
59448     return 0;
59449   }
59450   arg2 = *argp2;
59451   {
59452     try {
59453       result = (bool)(arg1)->OnAccessibilityPan(arg2);
59454     } catch (std::out_of_range& e) {
59455       {
59456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (std::exception& e) {
59459       {
59460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59461       };
59462     } catch (...) {
59463       {
59464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59465       };
59466     }
59467   }
59468   jresult = result;
59469   return jresult;
59470 }
59471
59472
59473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59474   unsigned int jresult ;
59475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59476   Dali::PanGesture arg2 ;
59477   Dali::PanGesture *argp2 ;
59478   bool result;
59479
59480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59481   argp2 = (Dali::PanGesture *)jarg2;
59482   if (!argp2) {
59483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
59484     return 0;
59485   }
59486   arg2 = *argp2;
59487   {
59488     try {
59489       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
59490     } catch (std::out_of_range& e) {
59491       {
59492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59493       };
59494     } catch (std::exception& e) {
59495       {
59496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (...) {
59499       {
59500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59501       };
59502     }
59503   }
59504   jresult = result;
59505   return jresult;
59506 }
59507
59508
59509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
59510   unsigned int jresult ;
59511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59512   Dali::TouchEvent *arg2 = 0 ;
59513   bool result;
59514
59515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59516   arg2 = (Dali::TouchEvent *)jarg2;
59517   if (!arg2) {
59518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59519     return 0;
59520   }
59521   {
59522     try {
59523       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
59524     } catch (std::out_of_range& e) {
59525       {
59526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59527       };
59528     } catch (std::exception& e) {
59529       {
59530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (...) {
59533       {
59534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59535       };
59536     }
59537   }
59538   jresult = result;
59539   return jresult;
59540 }
59541
59542
59543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59544   unsigned int jresult ;
59545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59546   Dali::TouchEvent *arg2 = 0 ;
59547   bool result;
59548
59549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59550   arg2 = (Dali::TouchEvent *)jarg2;
59551   if (!arg2) {
59552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59553     return 0;
59554   }
59555   {
59556     try {
59557       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
59558     } catch (std::out_of_range& e) {
59559       {
59560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59561       };
59562     } catch (std::exception& e) {
59563       {
59564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59565       };
59566     } catch (...) {
59567       {
59568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59569       };
59570     }
59571   }
59572   jresult = result;
59573   return jresult;
59574 }
59575
59576
59577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
59578   unsigned int jresult ;
59579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59580   bool arg2 ;
59581   bool result;
59582
59583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59584   arg2 = jarg2 ? true : false;
59585   {
59586     try {
59587       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
59588     } catch (std::out_of_range& e) {
59589       {
59590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59591       };
59592     } catch (std::exception& e) {
59593       {
59594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59595       };
59596     } catch (...) {
59597       {
59598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59599       };
59600     }
59601   }
59602   jresult = result;
59603   return jresult;
59604 }
59605
59606
59607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
59608   unsigned int jresult ;
59609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59610   bool arg2 ;
59611   bool result;
59612
59613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59614   arg2 = jarg2 ? true : false;
59615   {
59616     try {
59617       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
59618     } catch (std::out_of_range& e) {
59619       {
59620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59621       };
59622     } catch (std::exception& e) {
59623       {
59624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59625       };
59626     } catch (...) {
59627       {
59628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59629       };
59630     }
59631   }
59632   jresult = result;
59633   return jresult;
59634 }
59635
59636
59637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
59638   unsigned int jresult ;
59639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59640   bool result;
59641
59642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59643   {
59644     try {
59645       result = (bool)(arg1)->OnAccessibilityZoom();
59646     } catch (std::out_of_range& e) {
59647       {
59648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59649       };
59650     } catch (std::exception& e) {
59651       {
59652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59653       };
59654     } catch (...) {
59655       {
59656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59657       };
59658     }
59659   }
59660   jresult = result;
59661   return jresult;
59662 }
59663
59664
59665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
59666   unsigned int jresult ;
59667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59668   bool result;
59669
59670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59671   {
59672     try {
59673       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
59674     } catch (std::out_of_range& e) {
59675       {
59676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59677       };
59678     } catch (std::exception& e) {
59679       {
59680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59681       };
59682     } catch (...) {
59683       {
59684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59685       };
59686     }
59687   }
59688   jresult = result;
59689   return jresult;
59690 }
59691
59692
59693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
59694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59695
59696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59697   {
59698     try {
59699       (arg1)->OnKeyInputFocusGained();
59700     } catch (std::out_of_range& e) {
59701       {
59702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59703       };
59704     } catch (std::exception& e) {
59705       {
59706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59707       };
59708     } catch (...) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59711       };
59712     }
59713   }
59714 }
59715
59716
59717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
59718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59719
59720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59721   {
59722     try {
59723       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
59724     } catch (std::out_of_range& e) {
59725       {
59726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59727       };
59728     } catch (std::exception& e) {
59729       {
59730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59731       };
59732     } catch (...) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59735       };
59736     }
59737   }
59738 }
59739
59740
59741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
59742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59743
59744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59745   {
59746     try {
59747       (arg1)->OnKeyInputFocusLost();
59748     } catch (std::out_of_range& e) {
59749       {
59750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59751       };
59752     } catch (std::exception& e) {
59753       {
59754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59755       };
59756     } catch (...) {
59757       {
59758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59759       };
59760     }
59761   }
59762 }
59763
59764
59765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
59766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59767
59768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59769   {
59770     try {
59771       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
59772     } catch (std::out_of_range& e) {
59773       {
59774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59775       };
59776     } catch (std::exception& e) {
59777       {
59778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59779       };
59780     } catch (...) {
59781       {
59782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59783       };
59784     }
59785   }
59786 }
59787
59788
59789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
59790   void * jresult ;
59791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59792   Dali::Actor arg2 ;
59793   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
59794   bool arg4 ;
59795   Dali::Actor *argp2 ;
59796   Dali::Actor result;
59797
59798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59799   argp2 = (Dali::Actor *)jarg2;
59800   if (!argp2) {
59801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59802     return 0;
59803   }
59804   arg2 = *argp2;
59805   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
59806   arg4 = jarg4 ? true : false;
59807   {
59808     try {
59809       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
59810     } catch (std::out_of_range& e) {
59811       {
59812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59813       };
59814     } catch (std::exception& e) {
59815       {
59816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59817       };
59818     } catch (...) {
59819       {
59820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59821       };
59822     }
59823   }
59824   jresult = new Dali::Actor((const Dali::Actor &)result);
59825   return jresult;
59826 }
59827
59828
59829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
59830   void * jresult ;
59831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59832   Dali::Actor arg2 ;
59833   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
59834   bool arg4 ;
59835   Dali::Actor *argp2 ;
59836   Dali::Actor result;
59837
59838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59839   argp2 = (Dali::Actor *)jarg2;
59840   if (!argp2) {
59841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59842     return 0;
59843   }
59844   arg2 = *argp2;
59845   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
59846   arg4 = jarg4 ? true : false;
59847   {
59848     try {
59849       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
59850     } catch (std::out_of_range& e) {
59851       {
59852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59853       };
59854     } catch (std::exception& e) {
59855       {
59856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59857       };
59858     } catch (...) {
59859       {
59860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59861       };
59862     }
59863   }
59864   jresult = new Dali::Actor((const Dali::Actor &)result);
59865   return jresult;
59866 }
59867
59868
59869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
59870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59871   Dali::Actor arg2 ;
59872   Dali::Actor *argp2 ;
59873
59874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59875   argp2 = (Dali::Actor *)jarg2;
59876   if (!argp2) {
59877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59878     return ;
59879   }
59880   arg2 = *argp2;
59881   {
59882     try {
59883       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
59884     } catch (std::out_of_range& e) {
59885       {
59886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59887       };
59888     } catch (std::exception& e) {
59889       {
59890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59891       };
59892     } catch (...) {
59893       {
59894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59895       };
59896     }
59897   }
59898 }
59899
59900
59901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59903   Dali::Actor arg2 ;
59904   Dali::Actor *argp2 ;
59905
59906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59907   argp2 = (Dali::Actor *)jarg2;
59908   if (!argp2) {
59909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59910     return ;
59911   }
59912   arg2 = *argp2;
59913   {
59914     try {
59915       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
59916     } catch (std::out_of_range& e) {
59917       {
59918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59919       };
59920     } catch (std::exception& e) {
59921       {
59922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59923       };
59924     } catch (...) {
59925       {
59926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59927       };
59928     }
59929   }
59930 }
59931
59932
59933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
59934   unsigned int jresult ;
59935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59936   bool result;
59937
59938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59939   {
59940     try {
59941       result = (bool)(arg1)->OnKeyboardEnter();
59942     } catch (std::out_of_range& e) {
59943       {
59944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59945       };
59946     } catch (std::exception& e) {
59947       {
59948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59949       };
59950     } catch (...) {
59951       {
59952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59953       };
59954     }
59955   }
59956   jresult = result;
59957   return jresult;
59958 }
59959
59960
59961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
59962   unsigned int jresult ;
59963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59964   bool result;
59965
59966   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59967   {
59968     try {
59969       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
59970     } catch (std::out_of_range& e) {
59971       {
59972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59973       };
59974     } catch (std::exception& e) {
59975       {
59976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59977       };
59978     } catch (...) {
59979       {
59980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59981       };
59982     }
59983   }
59984   jresult = result;
59985   return jresult;
59986 }
59987
59988
59989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
59990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59991   Dali::PinchGesture *arg2 = 0 ;
59992
59993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59994   arg2 = (Dali::PinchGesture *)jarg2;
59995   if (!arg2) {
59996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
59997     return ;
59998   }
59999   {
60000     try {
60001       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
60002     } catch (std::out_of_range& e) {
60003       {
60004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60005       };
60006     } catch (std::exception& e) {
60007       {
60008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60009       };
60010     } catch (...) {
60011       {
60012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60013       };
60014     }
60015   }
60016 }
60017
60018
60019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60020   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60021   Dali::PinchGesture *arg2 = 0 ;
60022
60023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60024   arg2 = (Dali::PinchGesture *)jarg2;
60025   if (!arg2) {
60026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
60027     return ;
60028   }
60029   {
60030     try {
60031       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
60032     } catch (std::out_of_range& e) {
60033       {
60034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60035       };
60036     } catch (std::exception& e) {
60037       {
60038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60039       };
60040     } catch (...) {
60041       {
60042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60043       };
60044     }
60045   }
60046 }
60047
60048
60049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
60050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60051   Dali::PanGesture *arg2 = 0 ;
60052
60053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60054   arg2 = (Dali::PanGesture *)jarg2;
60055   if (!arg2) {
60056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
60057     return ;
60058   }
60059   {
60060     try {
60061       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
60062     } catch (std::out_of_range& e) {
60063       {
60064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60065       };
60066     } catch (std::exception& e) {
60067       {
60068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60069       };
60070     } catch (...) {
60071       {
60072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60073       };
60074     }
60075   }
60076 }
60077
60078
60079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60081   Dali::PanGesture *arg2 = 0 ;
60082
60083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60084   arg2 = (Dali::PanGesture *)jarg2;
60085   if (!arg2) {
60086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
60087     return ;
60088   }
60089   {
60090     try {
60091       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
60092     } catch (std::out_of_range& e) {
60093       {
60094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60095       };
60096     } catch (std::exception& e) {
60097       {
60098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60099       };
60100     } catch (...) {
60101       {
60102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60103       };
60104     }
60105   }
60106 }
60107
60108
60109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
60110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60111   Dali::TapGesture *arg2 = 0 ;
60112
60113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60114   arg2 = (Dali::TapGesture *)jarg2;
60115   if (!arg2) {
60116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
60117     return ;
60118   }
60119   {
60120     try {
60121       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
60122     } catch (std::out_of_range& e) {
60123       {
60124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60125       };
60126     } catch (std::exception& e) {
60127       {
60128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60129       };
60130     } catch (...) {
60131       {
60132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60133       };
60134     }
60135   }
60136 }
60137
60138
60139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60140   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60141   Dali::TapGesture *arg2 = 0 ;
60142
60143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60144   arg2 = (Dali::TapGesture *)jarg2;
60145   if (!arg2) {
60146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
60147     return ;
60148   }
60149   {
60150     try {
60151       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
60152     } catch (std::out_of_range& e) {
60153       {
60154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60155       };
60156     } catch (std::exception& e) {
60157       {
60158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60159       };
60160     } catch (...) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60163       };
60164     }
60165   }
60166 }
60167
60168
60169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
60170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60171   Dali::LongPressGesture *arg2 = 0 ;
60172
60173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60174   arg2 = (Dali::LongPressGesture *)jarg2;
60175   if (!arg2) {
60176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
60177     return ;
60178   }
60179   {
60180     try {
60181       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
60182     } catch (std::out_of_range& e) {
60183       {
60184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60185       };
60186     } catch (std::exception& e) {
60187       {
60188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60189       };
60190     } catch (...) {
60191       {
60192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60193       };
60194     }
60195   }
60196 }
60197
60198
60199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60201   Dali::LongPressGesture *arg2 = 0 ;
60202
60203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60204   arg2 = (Dali::LongPressGesture *)jarg2;
60205   if (!arg2) {
60206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
60207     return ;
60208   }
60209   {
60210     try {
60211       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
60212     } catch (std::out_of_range& e) {
60213       {
60214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60215       };
60216     } catch (std::exception& e) {
60217       {
60218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60219       };
60220     } catch (...) {
60221       {
60222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60223       };
60224     }
60225   }
60226 }
60227
60228
60229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
60230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60231   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60232   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60233
60234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60235   arg2 = (Dali::SlotObserver *)jarg2;
60236   arg3 = (Dali::CallbackBase *)jarg3;
60237   {
60238     try {
60239       (arg1)->SignalConnected(arg2,arg3);
60240     } catch (std::out_of_range& e) {
60241       {
60242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60243       };
60244     } catch (std::exception& e) {
60245       {
60246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60247       };
60248     } catch (...) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60251       };
60252     }
60253   }
60254 }
60255
60256
60257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60259   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60260   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60261
60262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60263   arg2 = (Dali::SlotObserver *)jarg2;
60264   arg3 = (Dali::CallbackBase *)jarg3;
60265   {
60266     try {
60267       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
60268     } catch (std::out_of_range& e) {
60269       {
60270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (std::exception& e) {
60273       {
60274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60275       };
60276     } catch (...) {
60277       {
60278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60279       };
60280     }
60281   }
60282 }
60283
60284
60285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
60286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60287   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60288   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60289
60290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60291   arg2 = (Dali::SlotObserver *)jarg2;
60292   arg3 = (Dali::CallbackBase *)jarg3;
60293   {
60294     try {
60295       (arg1)->SignalDisconnected(arg2,arg3);
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60303       };
60304     } catch (...) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60307       };
60308     }
60309   }
60310 }
60311
60312
60313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60315   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60316   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60317
60318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60319   arg2 = (Dali::SlotObserver *)jarg2;
60320   arg3 = (Dali::CallbackBase *)jarg3;
60321   {
60322     try {
60323       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
60324     } catch (std::out_of_range& e) {
60325       {
60326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60327       };
60328     } catch (std::exception& e) {
60329       {
60330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60335       };
60336     }
60337   }
60338 }
60339
60340
60341 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) {
60342   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
60343   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
60344   if (director) {
60345     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);
60346   }
60347 }
60348
60349
60350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
60351   void * jresult ;
60352   Dali::Toolkit::Control *arg1 = 0 ;
60353   Dali::Toolkit::Internal::Control *result = 0 ;
60354
60355   arg1 = (Dali::Toolkit::Control *)jarg1;
60356   if (!arg1) {
60357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
60358     return 0;
60359   }
60360   {
60361     try {
60362       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
60363     } catch (std::out_of_range& e) {
60364       {
60365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60366       };
60367     } catch (std::exception& e) {
60368       {
60369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60370       };
60371     } catch (...) {
60372       {
60373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60374       };
60375     }
60376   }
60377   jresult = (void *)result;
60378   return jresult;
60379 }
60380
60381
60382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
60383   int jresult ;
60384   int result;
60385
60386   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
60387   jresult = (int)result;
60388   return jresult;
60389 }
60390
60391
60392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
60393   int jresult ;
60394   int result;
60395
60396   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
60397   jresult = (int)result;
60398   return jresult;
60399 }
60400
60401
60402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
60403   int jresult ;
60404   int result;
60405
60406   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
60407   jresult = (int)result;
60408   return jresult;
60409 }
60410
60411
60412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
60413   int jresult ;
60414   int result;
60415
60416   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
60417   jresult = (int)result;
60418   return jresult;
60419 }
60420
60421
60422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
60423   int jresult ;
60424   int result;
60425
60426   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
60427   jresult = (int)result;
60428   return jresult;
60429 }
60430
60431
60432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
60433   void * jresult ;
60434   Dali::Toolkit::Control::Property *result = 0 ;
60435
60436   {
60437     try {
60438       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
60439     } catch (std::out_of_range& e) {
60440       {
60441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60442       };
60443     } catch (std::exception& e) {
60444       {
60445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60446       };
60447     } catch (...) {
60448       {
60449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60450       };
60451     }
60452   }
60453   jresult = (void *)result;
60454   return jresult;
60455 }
60456
60457
60458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
60459   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
60460
60461   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
60462   {
60463     try {
60464       delete arg1;
60465     } catch (std::out_of_range& e) {
60466       {
60467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60468       };
60469     } catch (std::exception& e) {
60470       {
60471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60472       };
60473     } catch (...) {
60474       {
60475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60476       };
60477     }
60478   }
60479 }
60480
60481
60482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
60483   void * jresult ;
60484   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
60485
60486   {
60487     try {
60488       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60500       };
60501     }
60502   }
60503   jresult = (void *)result;
60504   return jresult;
60505 }
60506
60507
60508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
60509   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
60510
60511   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
60512   {
60513     try {
60514       delete arg1;
60515     } catch (std::out_of_range& e) {
60516       {
60517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60518       };
60519     } catch (std::exception& e) {
60520       {
60521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60522       };
60523     } catch (...) {
60524       {
60525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60526       };
60527     }
60528   }
60529 }
60530
60531
60532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
60533   void * jresult ;
60534   Dali::Toolkit::Control result;
60535
60536   {
60537     try {
60538       result = Dali::Toolkit::Control::New();
60539     } catch (std::out_of_range& e) {
60540       {
60541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60542       };
60543     } catch (std::exception& e) {
60544       {
60545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60546       };
60547     } catch (...) {
60548       {
60549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60550       };
60551     }
60552   }
60553   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60554   return jresult;
60555 }
60556
60557
60558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
60559   void * jresult ;
60560   Dali::Toolkit::Control *result = 0 ;
60561
60562   {
60563     try {
60564       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
60565     } catch (std::out_of_range& e) {
60566       {
60567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60568       };
60569     } catch (std::exception& e) {
60570       {
60571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60572       };
60573     } catch (...) {
60574       {
60575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60576       };
60577     }
60578   }
60579   jresult = (void *)result;
60580   return jresult;
60581 }
60582
60583
60584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
60585   void * jresult ;
60586   Dali::Toolkit::Control *arg1 = 0 ;
60587   Dali::Toolkit::Control *result = 0 ;
60588
60589   arg1 = (Dali::Toolkit::Control *)jarg1;
60590   if (!arg1) {
60591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
60592     return 0;
60593   }
60594   {
60595     try {
60596       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
60597     } catch (std::out_of_range& e) {
60598       {
60599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (std::exception& e) {
60602       {
60603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60604       };
60605     } catch (...) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60608       };
60609     }
60610   }
60611   jresult = (void *)result;
60612   return jresult;
60613 }
60614
60615
60616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
60617   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60618
60619   arg1 = (Dali::Toolkit::Control *)jarg1;
60620   {
60621     try {
60622       delete arg1;
60623     } catch (std::out_of_range& e) {
60624       {
60625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60626       };
60627     } catch (std::exception& e) {
60628       {
60629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60630       };
60631     } catch (...) {
60632       {
60633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60634       };
60635     }
60636   }
60637 }
60638
60639
60640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
60641   void * jresult ;
60642   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60643   Dali::Toolkit::Control *arg2 = 0 ;
60644   Dali::Toolkit::Control *result = 0 ;
60645
60646   arg1 = (Dali::Toolkit::Control *)jarg1;
60647   arg2 = (Dali::Toolkit::Control *)jarg2;
60648   if (!arg2) {
60649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
60650     return 0;
60651   }
60652   {
60653     try {
60654       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
60655     } catch (std::out_of_range& e) {
60656       {
60657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (std::exception& e) {
60660       {
60661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60662       };
60663     } catch (...) {
60664       {
60665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60666       };
60667     }
60668   }
60669   jresult = (void *)result;
60670   return jresult;
60671 }
60672
60673
60674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
60675   void * jresult ;
60676   Dali::BaseHandle arg1 ;
60677   Dali::BaseHandle *argp1 ;
60678   Dali::Toolkit::Control result;
60679
60680   argp1 = (Dali::BaseHandle *)jarg1;
60681   if (!argp1) {
60682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60683     return 0;
60684   }
60685   arg1 = *argp1;
60686   {
60687     try {
60688       result = Dali::Toolkit::Control::DownCast(arg1);
60689     } catch (std::out_of_range& e) {
60690       {
60691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60692       };
60693     } catch (std::exception& e) {
60694       {
60695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60696       };
60697     } catch (...) {
60698       {
60699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60700       };
60701     }
60702   }
60703   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60704   return jresult;
60705 }
60706
60707
60708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
60709   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60710
60711   arg1 = (Dali::Toolkit::Control *)jarg1;
60712   {
60713     try {
60714       (arg1)->SetKeyInputFocus();
60715     } catch (std::out_of_range& e) {
60716       {
60717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60718       };
60719     } catch (std::exception& e) {
60720       {
60721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60722       };
60723     } catch (...) {
60724       {
60725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60726       };
60727     }
60728   }
60729 }
60730
60731
60732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
60733   unsigned int jresult ;
60734   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60735   bool result;
60736
60737   arg1 = (Dali::Toolkit::Control *)jarg1;
60738   {
60739     try {
60740       result = (bool)(arg1)->HasKeyInputFocus();
60741     } catch (std::out_of_range& e) {
60742       {
60743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (std::exception& e) {
60746       {
60747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60748       };
60749     } catch (...) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60752       };
60753     }
60754   }
60755   jresult = result;
60756   return jresult;
60757 }
60758
60759
60760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
60761   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60762
60763   arg1 = (Dali::Toolkit::Control *)jarg1;
60764   {
60765     try {
60766       (arg1)->ClearKeyInputFocus();
60767     } catch (std::out_of_range& e) {
60768       {
60769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60770       };
60771     } catch (std::exception& e) {
60772       {
60773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60774       };
60775     } catch (...) {
60776       {
60777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60778       };
60779     }
60780   }
60781 }
60782
60783
60784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
60785   void * jresult ;
60786   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60787   Dali::PinchGestureDetector result;
60788
60789   arg1 = (Dali::Toolkit::Control *)jarg1;
60790   {
60791     try {
60792       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
60793     } catch (std::out_of_range& e) {
60794       {
60795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60796       };
60797     } catch (std::exception& e) {
60798       {
60799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60800       };
60801     } catch (...) {
60802       {
60803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60804       };
60805     }
60806   }
60807   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60808   return jresult;
60809 }
60810
60811
60812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
60813   void * jresult ;
60814   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60815   Dali::PanGestureDetector result;
60816
60817   arg1 = (Dali::Toolkit::Control *)jarg1;
60818   {
60819     try {
60820       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
60821     } catch (std::out_of_range& e) {
60822       {
60823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (std::exception& e) {
60826       {
60827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60828       };
60829     } catch (...) {
60830       {
60831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60832       };
60833     }
60834   }
60835   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60836   return jresult;
60837 }
60838
60839
60840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
60841   void * jresult ;
60842   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60843   Dali::TapGestureDetector result;
60844
60845   arg1 = (Dali::Toolkit::Control *)jarg1;
60846   {
60847     try {
60848       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
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 = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60864   return jresult;
60865 }
60866
60867
60868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
60869   void * jresult ;
60870   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60871   Dali::LongPressGestureDetector result;
60872
60873   arg1 = (Dali::Toolkit::Control *)jarg1;
60874   {
60875     try {
60876       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
60877     } catch (std::out_of_range& e) {
60878       {
60879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60880       };
60881     } catch (std::exception& e) {
60882       {
60883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60884       };
60885     } catch (...) {
60886       {
60887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60888       };
60889     }
60890   }
60891   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60892   return jresult;
60893 }
60894
60895
60896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
60897   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60898   std::string *arg2 = 0 ;
60899
60900   arg1 = (Dali::Toolkit::Control *)jarg1;
60901   if (!jarg2) {
60902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60903     return ;
60904   }
60905   std::string arg2_str(jarg2);
60906   arg2 = &arg2_str;
60907   {
60908     try {
60909       (arg1)->SetStyleName((std::string const &)*arg2);
60910     } catch (std::out_of_range& e) {
60911       {
60912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60913       };
60914     } catch (std::exception& e) {
60915       {
60916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60917       };
60918     } catch (...) {
60919       {
60920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60921       };
60922     }
60923   }
60924
60925   //argout typemap for const std::string&
60926
60927 }
60928
60929
60930 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
60931   char * jresult ;
60932   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60933   std::string *result = 0 ;
60934
60935   arg1 = (Dali::Toolkit::Control *)jarg1;
60936   {
60937     try {
60938       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
60939     } catch (std::out_of_range& e) {
60940       {
60941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60942       };
60943     } catch (std::exception& e) {
60944       {
60945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60946       };
60947     } catch (...) {
60948       {
60949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60950       };
60951     }
60952   }
60953   jresult = SWIG_csharp_string_callback(result->c_str());
60954   return jresult;
60955 }
60956
60957
60958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
60959   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60960   Dali::Vector4 *arg2 = 0 ;
60961
60962   arg1 = (Dali::Toolkit::Control *)jarg1;
60963   arg2 = (Dali::Vector4 *)jarg2;
60964   if (!arg2) {
60965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60966     return ;
60967   }
60968   {
60969     try {
60970       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60971     } catch (std::out_of_range& e) {
60972       {
60973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60974       };
60975     } catch (std::exception& e) {
60976       {
60977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60978       };
60979     } catch (...) {
60980       {
60981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60982       };
60983     }
60984   }
60985 }
60986
60987
60988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
60989   void * jresult ;
60990   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60991   Dali::Vector4 result;
60992
60993   arg1 = (Dali::Toolkit::Control *)jarg1;
60994   {
60995     try {
60996       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
60997     } catch (std::out_of_range& e) {
60998       {
60999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61000       };
61001     } catch (std::exception& e) {
61002       {
61003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61004       };
61005     } catch (...) {
61006       {
61007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61008       };
61009     }
61010   }
61011   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
61012   return jresult;
61013 }
61014
61015
61016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
61017   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61018   Dali::Image arg2 ;
61019   Dali::Image *argp2 ;
61020
61021   arg1 = (Dali::Toolkit::Control *)jarg1;
61022   argp2 = (Dali::Image *)jarg2;
61023   if (!argp2) {
61024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61025     return ;
61026   }
61027   arg2 = *argp2;
61028   {
61029     try {
61030       (arg1)->SetBackgroundImage(arg2);
61031     } catch (std::out_of_range& e) {
61032       {
61033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61034       };
61035     } catch (std::exception& e) {
61036       {
61037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61038       };
61039     } catch (...) {
61040       {
61041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61042       };
61043     }
61044   }
61045 }
61046
61047
61048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
61049   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61050
61051   arg1 = (Dali::Toolkit::Control *)jarg1;
61052   {
61053     try {
61054       (arg1)->ClearBackground();
61055     } catch (std::out_of_range& e) {
61056       {
61057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61058       };
61059     } catch (std::exception& e) {
61060       {
61061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61062       };
61063     } catch (...) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61066       };
61067     }
61068   }
61069 }
61070
61071
61072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
61073   void * jresult ;
61074   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61075   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
61076
61077   arg1 = (Dali::Toolkit::Control *)jarg1;
61078   {
61079     try {
61080       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
61081     } catch (std::out_of_range& e) {
61082       {
61083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61084       };
61085     } catch (std::exception& e) {
61086       {
61087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61088       };
61089     } catch (...) {
61090       {
61091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61092       };
61093     }
61094   }
61095   jresult = (void *)result;
61096   return jresult;
61097 }
61098
61099
61100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
61101   void * jresult ;
61102   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61103   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61104
61105   arg1 = (Dali::Toolkit::Control *)jarg1;
61106   {
61107     try {
61108       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
61109     } catch (std::out_of_range& e) {
61110       {
61111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (std::exception& e) {
61114       {
61115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (...) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61120       };
61121     }
61122   }
61123   jresult = (void *)result;
61124   return jresult;
61125 }
61126
61127
61128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
61129   void * jresult ;
61130   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61131   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61132
61133   arg1 = (Dali::Toolkit::Control *)jarg1;
61134   {
61135     try {
61136       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
61137     } catch (std::out_of_range& e) {
61138       {
61139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61140       };
61141     } catch (std::exception& e) {
61142       {
61143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61144       };
61145     } catch (...) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61148       };
61149     }
61150   }
61151   jresult = (void *)result;
61152   return jresult;
61153 }
61154
61155
61156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
61157   void * jresult ;
61158   Dali::Toolkit::Internal::Control *arg1 = 0 ;
61159   Dali::Toolkit::Control *result = 0 ;
61160
61161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61162   if (!arg1) {
61163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
61164     return 0;
61165   }
61166   {
61167     try {
61168       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
61169     } catch (std::out_of_range& e) {
61170       {
61171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61172       };
61173     } catch (std::exception& e) {
61174       {
61175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61176       };
61177     } catch (...) {
61178       {
61179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61180       };
61181     }
61182   }
61183   jresult = (void *)result;
61184   return jresult;
61185 }
61186
61187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
61188 {
61189   void * jresult;
61190   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61191   arg1 = (Dali::Toolkit::Control *)jarg1;
61192
61193   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
61194
61195   Dali::Toolkit::TransitionData *arg2 = 0 ;
61196   Dali::Animation result;
61197
61198   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
61199   if (!arg2) {
61200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
61201     return 0;
61202   }
61203   {
61204     try {
61205       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
61206     } catch (std::out_of_range& e) {
61207       {
61208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (std::exception& e) {
61211       {
61212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61213       };
61214     } catch (...) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61217       };
61218     }
61219   }
61220   jresult = new Dali::Animation((const Dali::Animation &)result);
61221   return jresult;
61222 }
61223
61224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
61225   void * jresult ;
61226   Dali::Toolkit::Control *arg1 = 0 ;
61227   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
61228
61229   arg1 = (Dali::Toolkit::Control *)jarg1;
61230   if (!arg1) {
61231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
61232     return 0;
61233   }
61234   {
61235     try {
61236       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
61237     } catch (std::out_of_range& e) {
61238       {
61239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61240       };
61241     } catch (std::exception& e) {
61242       {
61243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61244       };
61245     } catch (...) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61248       };
61249     }
61250   }
61251   jresult = (void *)result;
61252   return jresult;
61253 }
61254
61255
61256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
61257   unsigned int jresult ;
61258   Dali::Toolkit::Control *arg1 = 0 ;
61259   bool result;
61260
61261   arg1 = (Dali::Toolkit::Control *)jarg1;
61262   if (!arg1) {
61263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
61264     return 0;
61265   }
61266   {
61267     try {
61268       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
61269     } catch (std::out_of_range& e) {
61270       {
61271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61272       };
61273     } catch (std::exception& e) {
61274       {
61275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61276       };
61277     } catch (...) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61280       };
61281     }
61282   }
61283   jresult = result;
61284   return jresult;
61285 }
61286
61287
61288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
61289   void * jresult ;
61290   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
61291
61292   {
61293     try {
61294       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
61295     } catch (std::out_of_range& e) {
61296       {
61297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61298       };
61299     } catch (std::exception& e) {
61300       {
61301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (...) {
61304       {
61305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61306       };
61307     }
61308   }
61309   jresult = (void *)result;
61310   return jresult;
61311 }
61312
61313
61314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
61315   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61316
61317   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61318   {
61319     try {
61320       delete arg1;
61321     } catch (std::out_of_range& e) {
61322       {
61323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61324       };
61325     } catch (std::exception& e) {
61326       {
61327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61328       };
61329     } catch (...) {
61330       {
61331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61332       };
61333     }
61334   }
61335 }
61336
61337
61338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
61339   void * jresult ;
61340   Dali::Toolkit::KeyInputFocusManager result;
61341
61342   {
61343     try {
61344       result = Dali::Toolkit::KeyInputFocusManager::Get();
61345     } catch (std::out_of_range& e) {
61346       {
61347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61348       };
61349     } catch (std::exception& e) {
61350       {
61351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61352       };
61353     } catch (...) {
61354       {
61355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61356       };
61357     }
61358   }
61359   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
61360   return jresult;
61361 }
61362
61363
61364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
61365   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61366   Dali::Toolkit::Control arg2 ;
61367   Dali::Toolkit::Control *argp2 ;
61368
61369   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61370   argp2 = (Dali::Toolkit::Control *)jarg2;
61371   if (!argp2) {
61372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
61373     return ;
61374   }
61375   arg2 = *argp2;
61376   {
61377     try {
61378       (arg1)->SetFocus(arg2);
61379     } catch (std::out_of_range& e) {
61380       {
61381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61382       };
61383     } catch (std::exception& e) {
61384       {
61385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61386       };
61387     } catch (...) {
61388       {
61389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61390       };
61391     }
61392   }
61393 }
61394
61395
61396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
61397   void * jresult ;
61398   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61399   Dali::Toolkit::Control result;
61400
61401   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61402   {
61403     try {
61404       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
61405     } catch (std::out_of_range& e) {
61406       {
61407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61408       };
61409     } catch (std::exception& e) {
61410       {
61411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61412       };
61413     } catch (...) {
61414       {
61415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61416       };
61417     }
61418   }
61419   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61420   return jresult;
61421 }
61422
61423
61424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
61425   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61426   Dali::Toolkit::Control arg2 ;
61427   Dali::Toolkit::Control *argp2 ;
61428
61429   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61430   argp2 = (Dali::Toolkit::Control *)jarg2;
61431   if (!argp2) {
61432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
61433     return ;
61434   }
61435   arg2 = *argp2;
61436   {
61437     try {
61438       (arg1)->RemoveFocus(arg2);
61439     } catch (std::out_of_range& e) {
61440       {
61441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61442       };
61443     } catch (std::exception& e) {
61444       {
61445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61446       };
61447     } catch (...) {
61448       {
61449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61450       };
61451     }
61452   }
61453 }
61454
61455
61456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
61457   void * jresult ;
61458   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61459   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
61460
61461   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61462   {
61463     try {
61464       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
61465     } catch (std::out_of_range& e) {
61466       {
61467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61468       };
61469     } catch (std::exception& e) {
61470       {
61471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61472       };
61473     } catch (...) {
61474       {
61475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61476       };
61477     }
61478   }
61479   jresult = (void *)result;
61480   return jresult;
61481 }
61482
61483
61484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
61485   void * jresult ;
61486   Dali::Toolkit::Alignment::Padding *result = 0 ;
61487
61488   {
61489     try {
61490       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
61491     } catch (std::out_of_range& e) {
61492       {
61493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61494       };
61495     } catch (std::exception& e) {
61496       {
61497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61498       };
61499     } catch (...) {
61500       {
61501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61502       };
61503     }
61504   }
61505   jresult = (void *)result;
61506   return jresult;
61507 }
61508
61509
61510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
61511   void * jresult ;
61512   float arg1 ;
61513   float arg2 ;
61514   float arg3 ;
61515   float arg4 ;
61516   Dali::Toolkit::Alignment::Padding *result = 0 ;
61517
61518   arg1 = (float)jarg1;
61519   arg2 = (float)jarg2;
61520   arg3 = (float)jarg3;
61521   arg4 = (float)jarg4;
61522   {
61523     try {
61524       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
61525     } catch (std::out_of_range& e) {
61526       {
61527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61528       };
61529     } catch (std::exception& e) {
61530       {
61531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61532       };
61533     } catch (...) {
61534       {
61535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61536       };
61537     }
61538   }
61539   jresult = (void *)result;
61540   return jresult;
61541 }
61542
61543
61544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
61545   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61546   float arg2 ;
61547
61548   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61549   arg2 = (float)jarg2;
61550   if (arg1) (arg1)->left = arg2;
61551 }
61552
61553
61554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
61555   float jresult ;
61556   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61557   float result;
61558
61559   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61560   result = (float) ((arg1)->left);
61561   jresult = result;
61562   return jresult;
61563 }
61564
61565
61566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
61567   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61568   float arg2 ;
61569
61570   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61571   arg2 = (float)jarg2;
61572   if (arg1) (arg1)->right = arg2;
61573 }
61574
61575
61576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
61577   float jresult ;
61578   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61579   float result;
61580
61581   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61582   result = (float) ((arg1)->right);
61583   jresult = result;
61584   return jresult;
61585 }
61586
61587
61588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
61589   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61590   float arg2 ;
61591
61592   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61593   arg2 = (float)jarg2;
61594   if (arg1) (arg1)->top = arg2;
61595 }
61596
61597
61598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
61599   float jresult ;
61600   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61601   float result;
61602
61603   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61604   result = (float) ((arg1)->top);
61605   jresult = result;
61606   return jresult;
61607 }
61608
61609
61610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
61611   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61612   float arg2 ;
61613
61614   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61615   arg2 = (float)jarg2;
61616   if (arg1) (arg1)->bottom = arg2;
61617 }
61618
61619
61620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
61621   float jresult ;
61622   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61623   float result;
61624
61625   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61626   result = (float) ((arg1)->bottom);
61627   jresult = result;
61628   return jresult;
61629 }
61630
61631
61632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
61633   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61634
61635   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61636   {
61637     try {
61638       delete arg1;
61639     } catch (std::out_of_range& e) {
61640       {
61641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61642       };
61643     } catch (std::exception& e) {
61644       {
61645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61646       };
61647     } catch (...) {
61648       {
61649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61650       };
61651     }
61652   }
61653 }
61654
61655
61656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
61657   void * jresult ;
61658   Dali::Toolkit::Alignment *result = 0 ;
61659
61660   {
61661     try {
61662       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
61663     } catch (std::out_of_range& e) {
61664       {
61665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61666       };
61667     } catch (std::exception& e) {
61668       {
61669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61670       };
61671     } catch (...) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61674       };
61675     }
61676   }
61677   jresult = (void *)result;
61678   return jresult;
61679 }
61680
61681
61682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
61683   void * jresult ;
61684   Dali::Toolkit::Alignment::Type arg1 ;
61685   Dali::Toolkit::Alignment::Type arg2 ;
61686   Dali::Toolkit::Alignment result;
61687
61688   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
61689   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
61690   {
61691     try {
61692       result = Dali::Toolkit::Alignment::New(arg1,arg2);
61693     } catch (std::out_of_range& e) {
61694       {
61695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61696       };
61697     } catch (std::exception& e) {
61698       {
61699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61700       };
61701     } catch (...) {
61702       {
61703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61704       };
61705     }
61706   }
61707   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61708   return jresult;
61709 }
61710
61711
61712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
61713   void * jresult ;
61714   Dali::Toolkit::Alignment::Type arg1 ;
61715   Dali::Toolkit::Alignment result;
61716
61717   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
61718   {
61719     try {
61720       result = Dali::Toolkit::Alignment::New(arg1);
61721     } catch (std::out_of_range& e) {
61722       {
61723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61724       };
61725     } catch (std::exception& e) {
61726       {
61727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61728       };
61729     } catch (...) {
61730       {
61731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61732       };
61733     }
61734   }
61735   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61736   return jresult;
61737 }
61738
61739
61740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
61741   void * jresult ;
61742   Dali::Toolkit::Alignment result;
61743
61744   {
61745     try {
61746       result = Dali::Toolkit::Alignment::New();
61747     } catch (std::out_of_range& e) {
61748       {
61749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61750       };
61751     } catch (std::exception& e) {
61752       {
61753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61754       };
61755     } catch (...) {
61756       {
61757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61758       };
61759     }
61760   }
61761   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61762   return jresult;
61763 }
61764
61765
61766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
61767   void * jresult ;
61768   Dali::Toolkit::Alignment *arg1 = 0 ;
61769   Dali::Toolkit::Alignment *result = 0 ;
61770
61771   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61772   if (!arg1) {
61773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
61774     return 0;
61775   }
61776   {
61777     try {
61778       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
61779     } catch (std::out_of_range& e) {
61780       {
61781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61782       };
61783     } catch (std::exception& e) {
61784       {
61785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61786       };
61787     } catch (...) {
61788       {
61789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61790       };
61791     }
61792   }
61793   jresult = (void *)result;
61794   return jresult;
61795 }
61796
61797
61798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
61799   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61800
61801   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61802   {
61803     try {
61804       delete arg1;
61805     } catch (std::out_of_range& e) {
61806       {
61807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61808       };
61809     } catch (std::exception& e) {
61810       {
61811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61812       };
61813     } catch (...) {
61814       {
61815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61816       };
61817     }
61818   }
61819 }
61820
61821
61822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
61823   void * jresult ;
61824   Dali::BaseHandle arg1 ;
61825   Dali::BaseHandle *argp1 ;
61826   Dali::Toolkit::Alignment result;
61827
61828   argp1 = (Dali::BaseHandle *)jarg1;
61829   if (!argp1) {
61830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61831     return 0;
61832   }
61833   arg1 = *argp1;
61834   {
61835     try {
61836       result = Dali::Toolkit::Alignment::DownCast(arg1);
61837     } catch (std::out_of_range& e) {
61838       {
61839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61840       };
61841     } catch (std::exception& e) {
61842       {
61843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61844       };
61845     } catch (...) {
61846       {
61847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61848       };
61849     }
61850   }
61851   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61852   return jresult;
61853 }
61854
61855
61856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
61857   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61858   Dali::Toolkit::Alignment::Type arg2 ;
61859
61860   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61861   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
61862   {
61863     try {
61864       (arg1)->SetAlignmentType(arg2);
61865     } catch (std::out_of_range& e) {
61866       {
61867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61868       };
61869     } catch (std::exception& e) {
61870       {
61871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61872       };
61873     } catch (...) {
61874       {
61875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61876       };
61877     }
61878   }
61879 }
61880
61881
61882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
61883   int jresult ;
61884   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61885   Dali::Toolkit::Alignment::Type result;
61886
61887   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61888   {
61889     try {
61890       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
61891     } catch (std::out_of_range& e) {
61892       {
61893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (std::exception& e) {
61896       {
61897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61902       };
61903     }
61904   }
61905   jresult = (int)result;
61906   return jresult;
61907 }
61908
61909
61910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
61911   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61912   Dali::Toolkit::Alignment::Scaling arg2 ;
61913
61914   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61915   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
61916   {
61917     try {
61918       (arg1)->SetScaling(arg2);
61919     } catch (std::out_of_range& e) {
61920       {
61921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61922       };
61923     } catch (std::exception& e) {
61924       {
61925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61926       };
61927     } catch (...) {
61928       {
61929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61930       };
61931     }
61932   }
61933 }
61934
61935
61936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
61937   int jresult ;
61938   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61939   Dali::Toolkit::Alignment::Scaling result;
61940
61941   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61942   {
61943     try {
61944       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
61945     } catch (std::out_of_range& e) {
61946       {
61947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61948       };
61949     } catch (std::exception& e) {
61950       {
61951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61952       };
61953     } catch (...) {
61954       {
61955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61956       };
61957     }
61958   }
61959   jresult = (int)result;
61960   return jresult;
61961 }
61962
61963
61964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
61965   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61966   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
61967
61968   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61969   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
61970   if (!arg2) {
61971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
61972     return ;
61973   }
61974   {
61975     try {
61976       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
61977     } catch (std::out_of_range& e) {
61978       {
61979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61980       };
61981     } catch (std::exception& e) {
61982       {
61983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61984       };
61985     } catch (...) {
61986       {
61987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61988       };
61989     }
61990   }
61991 }
61992
61993
61994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
61995   void * jresult ;
61996   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61997   Dali::Toolkit::Alignment::Padding *result = 0 ;
61998
61999   arg1 = (Dali::Toolkit::Alignment *)jarg1;
62000   {
62001     try {
62002       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
62003     } catch (std::out_of_range& e) {
62004       {
62005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62006       };
62007     } catch (std::exception& e) {
62008       {
62009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62010       };
62011     } catch (...) {
62012       {
62013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62014       };
62015     }
62016   }
62017   jresult = (void *)result;
62018   return jresult;
62019 }
62020
62021
62022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
62023   void * jresult ;
62024   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
62025   Dali::Toolkit::Alignment *arg2 = 0 ;
62026   Dali::Toolkit::Alignment *result = 0 ;
62027
62028   arg1 = (Dali::Toolkit::Alignment *)jarg1;
62029   arg2 = (Dali::Toolkit::Alignment *)jarg2;
62030   if (!arg2) {
62031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
62032     return 0;
62033   }
62034   {
62035     try {
62036       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
62037     } catch (std::out_of_range& e) {
62038       {
62039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62040       };
62041     } catch (std::exception& e) {
62042       {
62043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62044       };
62045     } catch (...) {
62046       {
62047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62048       };
62049     }
62050   }
62051   jresult = (void *)result;
62052   return jresult;
62053 }
62054
62055
62056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
62057   int jresult ;
62058   int result;
62059
62060   result = (int)Dali::Toolkit::Button::Property::DISABLED;
62061   jresult = (int)result;
62062   return jresult;
62063 }
62064
62065
62066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
62067   int jresult ;
62068   int result;
62069
62070   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
62071   jresult = (int)result;
62072   return jresult;
62073 }
62074
62075
62076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
62077   int jresult ;
62078   int result;
62079
62080   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
62081   jresult = (int)result;
62082   return jresult;
62083 }
62084
62085
62086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
62087   int jresult ;
62088   int result;
62089
62090   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
62091   jresult = (int)result;
62092   return jresult;
62093 }
62094
62095
62096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
62097   int jresult ;
62098   int result;
62099
62100   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
62101   jresult = (int)result;
62102   return jresult;
62103 }
62104
62105
62106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
62107   int jresult ;
62108   int result;
62109
62110   result = (int)Dali::Toolkit::Button::Property::SELECTED;
62111   jresult = (int)result;
62112   return jresult;
62113 }
62114
62115
62116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
62117   int jresult ;
62118   int result;
62119
62120   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
62121   jresult = (int)result;
62122   return jresult;
62123 }
62124
62125
62126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
62127   int jresult ;
62128   int result;
62129
62130   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
62131   jresult = (int)result;
62132   return jresult;
62133 }
62134
62135
62136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
62137   int jresult ;
62138   int result;
62139
62140   result = (int)Dali::Toolkit::Button::Property::LABEL;
62141   jresult = (int)result;
62142   return jresult;
62143 }
62144
62145
62146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
62147   int jresult ;
62148   int result;
62149
62150   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
62151   jresult = (int)result;
62152   return jresult;
62153 }
62154
62155
62156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
62157   void * jresult ;
62158   Dali::Toolkit::Button::Property *result = 0 ;
62159
62160   {
62161     try {
62162       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
62163     } catch (std::out_of_range& e) {
62164       {
62165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62166       };
62167     } catch (std::exception& e) {
62168       {
62169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62170       };
62171     } catch (...) {
62172       {
62173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62174       };
62175     }
62176   }
62177   jresult = (void *)result;
62178   return jresult;
62179 }
62180
62181
62182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
62183   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
62184
62185   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
62186   {
62187     try {
62188       delete arg1;
62189     } catch (std::out_of_range& e) {
62190       {
62191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62192       };
62193     } catch (std::exception& e) {
62194       {
62195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62196       };
62197     } catch (...) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62200       };
62201     }
62202   }
62203 }
62204
62205
62206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
62207   void * jresult ;
62208   Dali::Toolkit::Button *result = 0 ;
62209
62210   {
62211     try {
62212       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
62213     } catch (std::out_of_range& e) {
62214       {
62215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62216       };
62217     } catch (std::exception& e) {
62218       {
62219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62220       };
62221     } catch (...) {
62222       {
62223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62224       };
62225     }
62226   }
62227   jresult = (void *)result;
62228   return jresult;
62229 }
62230
62231
62232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
62233   void * jresult ;
62234   Dali::Toolkit::Button *arg1 = 0 ;
62235   Dali::Toolkit::Button *result = 0 ;
62236
62237   arg1 = (Dali::Toolkit::Button *)jarg1;
62238   if (!arg1) {
62239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
62240     return 0;
62241   }
62242   {
62243     try {
62244       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
62245     } catch (std::out_of_range& e) {
62246       {
62247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62248       };
62249     } catch (std::exception& e) {
62250       {
62251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62252       };
62253     } catch (...) {
62254       {
62255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62256       };
62257     }
62258   }
62259   jresult = (void *)result;
62260   return jresult;
62261 }
62262
62263
62264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
62265   void * jresult ;
62266   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62267   Dali::Toolkit::Button *arg2 = 0 ;
62268   Dali::Toolkit::Button *result = 0 ;
62269
62270   arg1 = (Dali::Toolkit::Button *)jarg1;
62271   arg2 = (Dali::Toolkit::Button *)jarg2;
62272   if (!arg2) {
62273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
62274     return 0;
62275   }
62276   {
62277     try {
62278       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
62279     } catch (std::out_of_range& e) {
62280       {
62281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62282       };
62283     } catch (std::exception& e) {
62284       {
62285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62286       };
62287     } catch (...) {
62288       {
62289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62290       };
62291     }
62292   }
62293   jresult = (void *)result;
62294   return jresult;
62295 }
62296
62297
62298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
62299   void * jresult ;
62300   Dali::BaseHandle arg1 ;
62301   Dali::BaseHandle *argp1 ;
62302   Dali::Toolkit::Button result;
62303
62304   argp1 = (Dali::BaseHandle *)jarg1;
62305   if (!argp1) {
62306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62307     return 0;
62308   }
62309   arg1 = *argp1;
62310   {
62311     try {
62312       result = Dali::Toolkit::Button::DownCast(arg1);
62313     } catch (std::out_of_range& e) {
62314       {
62315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62316       };
62317     } catch (std::exception& e) {
62318       {
62319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62320       };
62321     } catch (...) {
62322       {
62323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62324       };
62325     }
62326   }
62327   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
62328   return jresult;
62329 }
62330
62331
62332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
62333   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62334
62335   arg1 = (Dali::Toolkit::Button *)jarg1;
62336   {
62337     try {
62338       delete arg1;
62339     } catch (std::out_of_range& e) {
62340       {
62341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62342       };
62343     } catch (std::exception& e) {
62344       {
62345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62346       };
62347     } catch (...) {
62348       {
62349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62350       };
62351     }
62352   }
62353 }
62354
62355
62356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
62357   unsigned int jresult ;
62358   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62359   bool result;
62360
62361   arg1 = (Dali::Toolkit::Button *)jarg1;
62362   {
62363     try {
62364       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
62365     } catch (std::out_of_range& e) {
62366       {
62367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62368       };
62369     } catch (std::exception& e) {
62370       {
62371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62372       };
62373     } catch (...) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62376       };
62377     }
62378   }
62379   jresult = result;
62380   return jresult;
62381 }
62382
62383
62384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
62385   unsigned int jresult ;
62386   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62387   bool result;
62388
62389   arg1 = (Dali::Toolkit::Button *)jarg1;
62390   {
62391     try {
62392       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
62393     } catch (std::out_of_range& e) {
62394       {
62395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62396       };
62397     } catch (std::exception& e) {
62398       {
62399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62400       };
62401     } catch (...) {
62402       {
62403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62404       };
62405     }
62406   }
62407   jresult = result;
62408   return jresult;
62409 }
62410
62411
62412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
62413   float jresult ;
62414   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62415   float result;
62416
62417   arg1 = (Dali::Toolkit::Button *)jarg1;
62418   {
62419     try {
62420       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
62421     } catch (std::out_of_range& e) {
62422       {
62423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62424       };
62425     } catch (std::exception& e) {
62426       {
62427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62428       };
62429     } catch (...) {
62430       {
62431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62432       };
62433     }
62434   }
62435   jresult = result;
62436   return jresult;
62437 }
62438
62439
62440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
62441   float jresult ;
62442   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62443   float result;
62444
62445   arg1 = (Dali::Toolkit::Button *)jarg1;
62446   {
62447     try {
62448       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
62449     } catch (std::out_of_range& e) {
62450       {
62451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62452       };
62453     } catch (std::exception& e) {
62454       {
62455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62456       };
62457     } catch (...) {
62458       {
62459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62460       };
62461     }
62462   }
62463   jresult = result;
62464   return jresult;
62465 }
62466
62467
62468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
62469   unsigned int jresult ;
62470   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62471   bool result;
62472
62473   arg1 = (Dali::Toolkit::Button *)jarg1;
62474   {
62475     try {
62476       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
62477     } catch (std::out_of_range& e) {
62478       {
62479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62480       };
62481     } catch (std::exception& e) {
62482       {
62483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62484       };
62485     } catch (...) {
62486       {
62487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62488       };
62489     }
62490   }
62491   jresult = result;
62492   return jresult;
62493 }
62494
62495
62496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
62497   unsigned int jresult ;
62498   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62499   bool result;
62500
62501   arg1 = (Dali::Toolkit::Button *)jarg1;
62502   {
62503     try {
62504       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
62505     } catch (std::out_of_range& e) {
62506       {
62507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (std::exception& e) {
62510       {
62511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62512       };
62513     } catch (...) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62516       };
62517     }
62518   }
62519   jresult = result;
62520   return jresult;
62521 }
62522
62523
62524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
62525   float jresult ;
62526   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62527   float result;
62528
62529   arg1 = (Dali::Toolkit::Button *)jarg1;
62530   {
62531     try {
62532       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
62533     } catch (std::out_of_range& e) {
62534       {
62535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62536       };
62537     } catch (std::exception& e) {
62538       {
62539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62540       };
62541     } catch (...) {
62542       {
62543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62544       };
62545     }
62546   }
62547   jresult = result;
62548   return jresult;
62549 }
62550
62551
62552 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
62553   char * jresult ;
62554   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62555   std::string result;
62556
62557   arg1 = (Dali::Toolkit::Button *)jarg1;
62558   {
62559     try {
62560       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575   jresult = SWIG_csharp_string_callback((&result)->c_str());
62576   return jresult;
62577 }
62578
62579
62580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
62581   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62582   Dali::Actor arg2 ;
62583   Dali::Actor *argp2 ;
62584
62585   arg1 = (Dali::Toolkit::Button *)jarg1;
62586   argp2 = (Dali::Actor *)jarg2;
62587   if (!argp2) {
62588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62589     return ;
62590   }
62591   arg2 = *argp2;
62592   {
62593     try {
62594       (arg1)->SetLabel(arg2);
62595     } catch (std::out_of_range& e) {
62596       {
62597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62598       };
62599     } catch (std::exception& e) {
62600       {
62601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62602       };
62603     } catch (...) {
62604       {
62605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62606       };
62607     }
62608   }
62609 }
62610
62611
62612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
62613   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62614   Dali::Image arg2 ;
62615   Dali::Image *argp2 ;
62616
62617   arg1 = (Dali::Toolkit::Button *)jarg1;
62618   argp2 = (Dali::Image *)jarg2;
62619   if (!argp2) {
62620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62621     return ;
62622   }
62623   arg2 = *argp2;
62624   {
62625     try {
62626       (arg1)->SetButtonImage(arg2);
62627     } catch (std::out_of_range& e) {
62628       {
62629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62630       };
62631     } catch (std::exception& e) {
62632       {
62633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62634       };
62635     } catch (...) {
62636       {
62637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62638       };
62639     }
62640   }
62641 }
62642
62643
62644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
62645   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62646   Dali::Image arg2 ;
62647   Dali::Image *argp2 ;
62648
62649   arg1 = (Dali::Toolkit::Button *)jarg1;
62650   argp2 = (Dali::Image *)jarg2;
62651   if (!argp2) {
62652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62653     return ;
62654   }
62655   arg2 = *argp2;
62656   {
62657     try {
62658       (arg1)->SetSelectedImage(arg2);
62659     } catch (std::out_of_range& e) {
62660       {
62661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62662       };
62663     } catch (std::exception& e) {
62664       {
62665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62666       };
62667     } catch (...) {
62668       {
62669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62670       };
62671     }
62672   }
62673 }
62674
62675
62676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
62677   void * jresult ;
62678   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62679   Dali::Actor result;
62680
62681   arg1 = (Dali::Toolkit::Button *)jarg1;
62682   {
62683     try {
62684       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62692       };
62693     } catch (...) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62696       };
62697     }
62698   }
62699   jresult = new Dali::Actor((const Dali::Actor &)result);
62700   return jresult;
62701 }
62702
62703
62704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
62705   void * jresult ;
62706   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62707   Dali::Actor result;
62708
62709   arg1 = (Dali::Toolkit::Button *)jarg1;
62710   {
62711     try {
62712       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
62713     } catch (std::out_of_range& e) {
62714       {
62715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62716       };
62717     } catch (std::exception& e) {
62718       {
62719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62720       };
62721     } catch (...) {
62722       {
62723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62724       };
62725     }
62726   }
62727   jresult = new Dali::Actor((const Dali::Actor &)result);
62728   return jresult;
62729 }
62730
62731
62732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
62733   void * jresult ;
62734   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62735   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62736
62737   arg1 = (Dali::Toolkit::Button *)jarg1;
62738   {
62739     try {
62740       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
62741     } catch (std::out_of_range& e) {
62742       {
62743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62744       };
62745     } catch (std::exception& e) {
62746       {
62747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62748       };
62749     } catch (...) {
62750       {
62751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62752       };
62753     }
62754   }
62755   jresult = (void *)result;
62756   return jresult;
62757 }
62758
62759
62760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
62761   void * jresult ;
62762   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62763   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62764
62765   arg1 = (Dali::Toolkit::Button *)jarg1;
62766   {
62767     try {
62768       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
62769     } catch (std::out_of_range& e) {
62770       {
62771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62772       };
62773     } catch (std::exception& e) {
62774       {
62775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62776       };
62777     } catch (...) {
62778       {
62779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62780       };
62781     }
62782   }
62783   jresult = (void *)result;
62784   return jresult;
62785 }
62786
62787
62788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
62789   void * jresult ;
62790   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62791   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62792
62793   arg1 = (Dali::Toolkit::Button *)jarg1;
62794   {
62795     try {
62796       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
62797     } catch (std::out_of_range& e) {
62798       {
62799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62800       };
62801     } catch (std::exception& e) {
62802       {
62803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62804       };
62805     } catch (...) {
62806       {
62807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62808       };
62809     }
62810   }
62811   jresult = (void *)result;
62812   return jresult;
62813 }
62814
62815
62816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
62817   void * jresult ;
62818   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62819   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62820
62821   arg1 = (Dali::Toolkit::Button *)jarg1;
62822   {
62823     try {
62824       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
62825     } catch (std::out_of_range& e) {
62826       {
62827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62828       };
62829     } catch (std::exception& e) {
62830       {
62831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62832       };
62833     } catch (...) {
62834       {
62835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62836       };
62837     }
62838   }
62839   jresult = (void *)result;
62840   return jresult;
62841 }
62842
62843
62844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
62845   void * jresult ;
62846   Dali::Toolkit::CheckBoxButton *result = 0 ;
62847
62848   {
62849     try {
62850       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
62851     } catch (std::out_of_range& e) {
62852       {
62853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62854       };
62855     } catch (std::exception& e) {
62856       {
62857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62858       };
62859     } catch (...) {
62860       {
62861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62862       };
62863     }
62864   }
62865   jresult = (void *)result;
62866   return jresult;
62867 }
62868
62869
62870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
62871   void * jresult ;
62872   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
62873   Dali::Toolkit::CheckBoxButton *result = 0 ;
62874
62875   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62876   if (!arg1) {
62877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
62878     return 0;
62879   }
62880   {
62881     try {
62882       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
62883     } catch (std::out_of_range& e) {
62884       {
62885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62886       };
62887     } catch (std::exception& e) {
62888       {
62889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62890       };
62891     } catch (...) {
62892       {
62893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62894       };
62895     }
62896   }
62897   jresult = (void *)result;
62898   return jresult;
62899 }
62900
62901
62902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
62903   void * jresult ;
62904   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
62905   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
62906   Dali::Toolkit::CheckBoxButton *result = 0 ;
62907
62908   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62909   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
62910   if (!arg2) {
62911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
62912     return 0;
62913   }
62914   {
62915     try {
62916       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
62917     } catch (std::out_of_range& e) {
62918       {
62919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62920       };
62921     } catch (std::exception& e) {
62922       {
62923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62924       };
62925     } catch (...) {
62926       {
62927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62928       };
62929     }
62930   }
62931   jresult = (void *)result;
62932   return jresult;
62933 }
62934
62935
62936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
62937   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
62938
62939   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62940   {
62941     try {
62942       delete arg1;
62943     } catch (std::out_of_range& e) {
62944       {
62945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62946       };
62947     } catch (std::exception& e) {
62948       {
62949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62950       };
62951     } catch (...) {
62952       {
62953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62954       };
62955     }
62956   }
62957 }
62958
62959
62960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
62961   void * jresult ;
62962   Dali::Toolkit::CheckBoxButton result;
62963
62964   {
62965     try {
62966       result = Dali::Toolkit::CheckBoxButton::New();
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (...) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62978       };
62979     }
62980   }
62981   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
62982   return jresult;
62983 }
62984
62985
62986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
62987   void * jresult ;
62988   Dali::BaseHandle arg1 ;
62989   Dali::BaseHandle *argp1 ;
62990   Dali::Toolkit::CheckBoxButton result;
62991
62992   argp1 = (Dali::BaseHandle *)jarg1;
62993   if (!argp1) {
62994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62995     return 0;
62996   }
62997   arg1 = *argp1;
62998   {
62999     try {
63000       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
63001     } catch (std::out_of_range& e) {
63002       {
63003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63004       };
63005     } catch (std::exception& e) {
63006       {
63007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63008       };
63009     } catch (...) {
63010       {
63011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63012       };
63013     }
63014   }
63015   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
63016   return jresult;
63017 }
63018
63019
63020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
63021   int jresult ;
63022   int result;
63023
63024   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
63025   jresult = (int)result;
63026   return jresult;
63027 }
63028
63029
63030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
63031   int jresult ;
63032   int result;
63033
63034   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
63035   jresult = (int)result;
63036   return jresult;
63037 }
63038
63039
63040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
63041   int jresult ;
63042   int result;
63043
63044   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
63045   jresult = (int)result;
63046   return jresult;
63047 }
63048
63049
63050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
63051   int jresult ;
63052   int result;
63053
63054   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
63055   jresult = (int)result;
63056   return jresult;
63057 }
63058
63059
63060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
63061   int jresult ;
63062   int result;
63063
63064   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
63065   jresult = (int)result;
63066   return jresult;
63067 }
63068
63069
63070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
63071   void * jresult ;
63072   Dali::Toolkit::PushButton::Property *result = 0 ;
63073
63074   {
63075     try {
63076       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63084       };
63085     } catch (...) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63088       };
63089     }
63090   }
63091   jresult = (void *)result;
63092   return jresult;
63093 }
63094
63095
63096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
63097   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
63098
63099   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
63100   {
63101     try {
63102       delete arg1;
63103     } catch (std::out_of_range& e) {
63104       {
63105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63106       };
63107     } catch (std::exception& e) {
63108       {
63109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63110       };
63111     } catch (...) {
63112       {
63113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63114       };
63115     }
63116   }
63117 }
63118
63119
63120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
63121   void * jresult ;
63122   Dali::Toolkit::PushButton *result = 0 ;
63123
63124   {
63125     try {
63126       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
63127     } catch (std::out_of_range& e) {
63128       {
63129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63130       };
63131     } catch (std::exception& e) {
63132       {
63133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63134       };
63135     } catch (...) {
63136       {
63137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63138       };
63139     }
63140   }
63141   jresult = (void *)result;
63142   return jresult;
63143 }
63144
63145
63146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
63147   void * jresult ;
63148   Dali::Toolkit::PushButton *arg1 = 0 ;
63149   Dali::Toolkit::PushButton *result = 0 ;
63150
63151   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63152   if (!arg1) {
63153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
63154     return 0;
63155   }
63156   {
63157     try {
63158       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
63159     } catch (std::out_of_range& e) {
63160       {
63161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63162       };
63163     } catch (std::exception& e) {
63164       {
63165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63170       };
63171     }
63172   }
63173   jresult = (void *)result;
63174   return jresult;
63175 }
63176
63177
63178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
63179   void * jresult ;
63180   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63181   Dali::Toolkit::PushButton *arg2 = 0 ;
63182   Dali::Toolkit::PushButton *result = 0 ;
63183
63184   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63185   arg2 = (Dali::Toolkit::PushButton *)jarg2;
63186   if (!arg2) {
63187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
63188     return 0;
63189   }
63190   {
63191     try {
63192       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
63193     } catch (std::out_of_range& e) {
63194       {
63195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63196       };
63197     } catch (std::exception& e) {
63198       {
63199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63200       };
63201     } catch (...) {
63202       {
63203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63204       };
63205     }
63206   }
63207   jresult = (void *)result;
63208   return jresult;
63209 }
63210
63211
63212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
63213   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63214
63215   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63216   {
63217     try {
63218       delete arg1;
63219     } catch (std::out_of_range& e) {
63220       {
63221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63222       };
63223     } catch (std::exception& e) {
63224       {
63225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63226       };
63227     } catch (...) {
63228       {
63229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63230       };
63231     }
63232   }
63233 }
63234
63235
63236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
63237   void * jresult ;
63238   Dali::Toolkit::PushButton result;
63239
63240   {
63241     try {
63242       result = Dali::Toolkit::PushButton::New();
63243     } catch (std::out_of_range& e) {
63244       {
63245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63246       };
63247     } catch (std::exception& e) {
63248       {
63249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63250       };
63251     } catch (...) {
63252       {
63253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63254       };
63255     }
63256   }
63257   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
63258   return jresult;
63259 }
63260
63261
63262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
63263   void * jresult ;
63264   Dali::BaseHandle arg1 ;
63265   Dali::BaseHandle *argp1 ;
63266   Dali::Toolkit::PushButton result;
63267
63268   argp1 = (Dali::BaseHandle *)jarg1;
63269   if (!argp1) {
63270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63271     return 0;
63272   }
63273   arg1 = *argp1;
63274   {
63275     try {
63276       result = Dali::Toolkit::PushButton::DownCast(arg1);
63277     } catch (std::out_of_range& e) {
63278       {
63279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63280       };
63281     } catch (std::exception& e) {
63282       {
63283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63284       };
63285     } catch (...) {
63286       {
63287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63288       };
63289     }
63290   }
63291   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
63292   return jresult;
63293 }
63294
63295
63296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
63297   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63298   Dali::Image arg2 ;
63299   Dali::Image *argp2 ;
63300
63301   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63302   argp2 = (Dali::Image *)jarg2;
63303   if (!argp2) {
63304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63305     return ;
63306   }
63307   arg2 = *argp2;
63308   {
63309     try {
63310       (arg1)->SetButtonImage(arg2);
63311     } catch (std::out_of_range& e) {
63312       {
63313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63314       };
63315     } catch (std::exception& e) {
63316       {
63317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63318       };
63319     } catch (...) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63322       };
63323     }
63324   }
63325 }
63326
63327
63328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
63329   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63330   Dali::Actor arg2 ;
63331   Dali::Actor *argp2 ;
63332
63333   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63334   argp2 = (Dali::Actor *)jarg2;
63335   if (!argp2) {
63336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63337     return ;
63338   }
63339   arg2 = *argp2;
63340   {
63341     try {
63342       (arg1)->SetButtonImage(arg2);
63343     } catch (std::out_of_range& e) {
63344       {
63345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63346       };
63347     } catch (std::exception& e) {
63348       {
63349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63350       };
63351     } catch (...) {
63352       {
63353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63354       };
63355     }
63356   }
63357 }
63358
63359
63360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
63361   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63362   Dali::Actor arg2 ;
63363   Dali::Actor *argp2 ;
63364
63365   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63366   argp2 = (Dali::Actor *)jarg2;
63367   if (!argp2) {
63368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63369     return ;
63370   }
63371   arg2 = *argp2;
63372   {
63373     try {
63374       (arg1)->SetBackgroundImage(arg2);
63375     } catch (std::out_of_range& e) {
63376       {
63377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63378       };
63379     } catch (std::exception& e) {
63380       {
63381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63382       };
63383     } catch (...) {
63384       {
63385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63386       };
63387     }
63388   }
63389 }
63390
63391
63392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
63393   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63394   Dali::Image arg2 ;
63395   Dali::Image *argp2 ;
63396
63397   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63398   argp2 = (Dali::Image *)jarg2;
63399   if (!argp2) {
63400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63401     return ;
63402   }
63403   arg2 = *argp2;
63404   {
63405     try {
63406       (arg1)->SetSelectedImage(arg2);
63407     } catch (std::out_of_range& e) {
63408       {
63409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63410       };
63411     } catch (std::exception& e) {
63412       {
63413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63414       };
63415     } catch (...) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63418       };
63419     }
63420   }
63421 }
63422
63423
63424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
63425   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63426   Dali::Actor arg2 ;
63427   Dali::Actor *argp2 ;
63428
63429   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63430   argp2 = (Dali::Actor *)jarg2;
63431   if (!argp2) {
63432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63433     return ;
63434   }
63435   arg2 = *argp2;
63436   {
63437     try {
63438       (arg1)->SetSelectedImage(arg2);
63439     } catch (std::out_of_range& e) {
63440       {
63441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63442       };
63443     } catch (std::exception& e) {
63444       {
63445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63450       };
63451     }
63452   }
63453 }
63454
63455
63456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
63457   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63458   Dali::Actor arg2 ;
63459   Dali::Actor *argp2 ;
63460
63461   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63462   argp2 = (Dali::Actor *)jarg2;
63463   if (!argp2) {
63464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63465     return ;
63466   }
63467   arg2 = *argp2;
63468   {
63469     try {
63470       (arg1)->SetSelectedBackgroundImage(arg2);
63471     } catch (std::out_of_range& e) {
63472       {
63473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63474       };
63475     } catch (std::exception& e) {
63476       {
63477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63478       };
63479     } catch (...) {
63480       {
63481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63482       };
63483     }
63484   }
63485 }
63486
63487
63488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
63489   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63490   Dali::Actor arg2 ;
63491   Dali::Actor *argp2 ;
63492
63493   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63494   argp2 = (Dali::Actor *)jarg2;
63495   if (!argp2) {
63496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63497     return ;
63498   }
63499   arg2 = *argp2;
63500   {
63501     try {
63502       (arg1)->SetDisabledBackgroundImage(arg2);
63503     } catch (std::out_of_range& e) {
63504       {
63505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63506       };
63507     } catch (std::exception& e) {
63508       {
63509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63510       };
63511     } catch (...) {
63512       {
63513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63514       };
63515     }
63516   }
63517 }
63518
63519
63520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
63521   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63522   Dali::Actor arg2 ;
63523   Dali::Actor *argp2 ;
63524
63525   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63526   argp2 = (Dali::Actor *)jarg2;
63527   if (!argp2) {
63528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63529     return ;
63530   }
63531   arg2 = *argp2;
63532   {
63533     try {
63534       (arg1)->SetDisabledImage(arg2);
63535     } catch (std::out_of_range& e) {
63536       {
63537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63538       };
63539     } catch (std::exception& e) {
63540       {
63541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63542       };
63543     } catch (...) {
63544       {
63545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63546       };
63547     }
63548   }
63549 }
63550
63551
63552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
63553   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63554   Dali::Actor arg2 ;
63555   Dali::Actor *argp2 ;
63556
63557   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63558   argp2 = (Dali::Actor *)jarg2;
63559   if (!argp2) {
63560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63561     return ;
63562   }
63563   arg2 = *argp2;
63564   {
63565     try {
63566       (arg1)->SetDisabledSelectedImage(arg2);
63567     } catch (std::out_of_range& e) {
63568       {
63569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63570       };
63571     } catch (std::exception& e) {
63572       {
63573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63578       };
63579     }
63580   }
63581 }
63582
63583
63584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
63585   void * jresult ;
63586   Dali::Toolkit::RadioButton *result = 0 ;
63587
63588   {
63589     try {
63590       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
63591     } catch (std::out_of_range& e) {
63592       {
63593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63594       };
63595     } catch (std::exception& e) {
63596       {
63597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63598       };
63599     } catch (...) {
63600       {
63601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63602       };
63603     }
63604   }
63605   jresult = (void *)result;
63606   return jresult;
63607 }
63608
63609
63610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
63611   void * jresult ;
63612   Dali::Toolkit::RadioButton *arg1 = 0 ;
63613   Dali::Toolkit::RadioButton *result = 0 ;
63614
63615   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63616   if (!arg1) {
63617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
63618     return 0;
63619   }
63620   {
63621     try {
63622       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
63623     } catch (std::out_of_range& e) {
63624       {
63625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63626       };
63627     } catch (std::exception& e) {
63628       {
63629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63630       };
63631     } catch (...) {
63632       {
63633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63634       };
63635     }
63636   }
63637   jresult = (void *)result;
63638   return jresult;
63639 }
63640
63641
63642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
63643   void * jresult ;
63644   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
63645   Dali::Toolkit::RadioButton *arg2 = 0 ;
63646   Dali::Toolkit::RadioButton *result = 0 ;
63647
63648   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63649   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
63650   if (!arg2) {
63651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
63652     return 0;
63653   }
63654   {
63655     try {
63656       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
63657     } catch (std::out_of_range& e) {
63658       {
63659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63660       };
63661     } catch (std::exception& e) {
63662       {
63663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63664       };
63665     } catch (...) {
63666       {
63667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63668       };
63669     }
63670   }
63671   jresult = (void *)result;
63672   return jresult;
63673 }
63674
63675
63676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
63677   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
63678
63679   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63680   {
63681     try {
63682       delete arg1;
63683     } catch (std::out_of_range& e) {
63684       {
63685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63686       };
63687     } catch (std::exception& e) {
63688       {
63689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63690       };
63691     } catch (...) {
63692       {
63693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63694       };
63695     }
63696   }
63697 }
63698
63699
63700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
63701   void * jresult ;
63702   Dali::Toolkit::RadioButton result;
63703
63704   {
63705     try {
63706       result = Dali::Toolkit::RadioButton::New();
63707     } catch (std::out_of_range& e) {
63708       {
63709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63710       };
63711     } catch (std::exception& e) {
63712       {
63713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63714       };
63715     } catch (...) {
63716       {
63717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63718       };
63719     }
63720   }
63721   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63722   return jresult;
63723 }
63724
63725
63726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
63727   void * jresult ;
63728   std::string *arg1 = 0 ;
63729   Dali::Toolkit::RadioButton result;
63730
63731   if (!jarg1) {
63732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63733     return 0;
63734   }
63735   std::string arg1_str(jarg1);
63736   arg1 = &arg1_str;
63737   {
63738     try {
63739       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
63740     } catch (std::out_of_range& e) {
63741       {
63742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63743       };
63744     } catch (std::exception& e) {
63745       {
63746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63747       };
63748     } catch (...) {
63749       {
63750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63751       };
63752     }
63753   }
63754   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63755
63756   //argout typemap for const std::string&
63757
63758   return jresult;
63759 }
63760
63761
63762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
63763   void * jresult ;
63764   Dali::BaseHandle arg1 ;
63765   Dali::BaseHandle *argp1 ;
63766   Dali::Toolkit::RadioButton result;
63767
63768   argp1 = (Dali::BaseHandle *)jarg1;
63769   if (!argp1) {
63770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63771     return 0;
63772   }
63773   arg1 = *argp1;
63774   {
63775     try {
63776       result = Dali::Toolkit::RadioButton::DownCast(arg1);
63777     } catch (std::out_of_range& e) {
63778       {
63779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63780       };
63781     } catch (std::exception& e) {
63782       {
63783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63784       };
63785     } catch (...) {
63786       {
63787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63788       };
63789     }
63790   }
63791   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63792   return jresult;
63793 }
63794
63795
63796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
63797   int jresult ;
63798   int result;
63799
63800   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
63801   jresult = (int)result;
63802   return jresult;
63803 }
63804
63805
63806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
63807   int jresult ;
63808   int result;
63809
63810   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
63811   jresult = (int)result;
63812   return jresult;
63813 }
63814
63815
63816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
63817   int jresult ;
63818   int result;
63819
63820   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
63821   jresult = (int)result;
63822   return jresult;
63823 }
63824
63825
63826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
63827   int jresult ;
63828   int result;
63829
63830   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
63831   jresult = (int)result;
63832   return jresult;
63833 }
63834
63835
63836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
63837   int jresult ;
63838   int result;
63839
63840   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
63841   jresult = (int)result;
63842   return jresult;
63843 }
63844
63845
63846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
63847   int jresult ;
63848   int result;
63849
63850   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
63851   jresult = (int)result;
63852   return jresult;
63853 }
63854
63855
63856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
63857   void * jresult ;
63858   Dali::Toolkit::FlexContainer::Property *result = 0 ;
63859
63860   {
63861     try {
63862       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
63863     } catch (std::out_of_range& e) {
63864       {
63865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63866       };
63867     } catch (std::exception& e) {
63868       {
63869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63870       };
63871     } catch (...) {
63872       {
63873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63874       };
63875     }
63876   }
63877   jresult = (void *)result;
63878   return jresult;
63879 }
63880
63881
63882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
63883   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
63884
63885   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
63886   {
63887     try {
63888       delete arg1;
63889     } catch (std::out_of_range& e) {
63890       {
63891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63892       };
63893     } catch (std::exception& e) {
63894       {
63895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63896       };
63897     } catch (...) {
63898       {
63899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63900       };
63901     }
63902   }
63903 }
63904
63905
63906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
63907   int jresult ;
63908   int result;
63909
63910   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
63911   jresult = (int)result;
63912   return jresult;
63913 }
63914
63915
63916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
63917   int jresult ;
63918   int result;
63919
63920   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
63921   jresult = (int)result;
63922   return jresult;
63923 }
63924
63925
63926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
63927   int jresult ;
63928   int result;
63929
63930   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
63931   jresult = (int)result;
63932   return jresult;
63933 }
63934
63935
63936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
63937   void * jresult ;
63938   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
63939
63940   {
63941     try {
63942       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
63943     } catch (std::out_of_range& e) {
63944       {
63945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63946       };
63947     } catch (std::exception& e) {
63948       {
63949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63950       };
63951     } catch (...) {
63952       {
63953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63954       };
63955     }
63956   }
63957   jresult = (void *)result;
63958   return jresult;
63959 }
63960
63961
63962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
63963   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
63964
63965   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
63966   {
63967     try {
63968       delete arg1;
63969     } catch (std::out_of_range& e) {
63970       {
63971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63972       };
63973     } catch (std::exception& e) {
63974       {
63975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63976       };
63977     } catch (...) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63980       };
63981     }
63982   }
63983 }
63984
63985
63986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
63987   void * jresult ;
63988   Dali::Toolkit::FlexContainer *result = 0 ;
63989
63990   {
63991     try {
63992       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
63993     } catch (std::out_of_range& e) {
63994       {
63995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63996       };
63997     } catch (std::exception& e) {
63998       {
63999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64000       };
64001     } catch (...) {
64002       {
64003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64004       };
64005     }
64006   }
64007   jresult = (void *)result;
64008   return jresult;
64009 }
64010
64011
64012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
64013   void * jresult ;
64014   Dali::Toolkit::FlexContainer *arg1 = 0 ;
64015   Dali::Toolkit::FlexContainer *result = 0 ;
64016
64017   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
64018   if (!arg1) {
64019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
64020     return 0;
64021   }
64022   {
64023     try {
64024       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
64025     } catch (std::out_of_range& e) {
64026       {
64027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64028       };
64029     } catch (std::exception& e) {
64030       {
64031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64032       };
64033     } catch (...) {
64034       {
64035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64036       };
64037     }
64038   }
64039   jresult = (void *)result;
64040   return jresult;
64041 }
64042
64043
64044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
64045   void * jresult ;
64046   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
64047   Dali::Toolkit::FlexContainer *arg2 = 0 ;
64048   Dali::Toolkit::FlexContainer *result = 0 ;
64049
64050   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
64051   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
64052   if (!arg2) {
64053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
64054     return 0;
64055   }
64056   {
64057     try {
64058       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
64059     } catch (std::out_of_range& e) {
64060       {
64061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64062       };
64063     } catch (std::exception& e) {
64064       {
64065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64066       };
64067     } catch (...) {
64068       {
64069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64070       };
64071     }
64072   }
64073   jresult = (void *)result;
64074   return jresult;
64075 }
64076
64077
64078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
64079   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
64080
64081   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
64082   {
64083     try {
64084       delete arg1;
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64096       };
64097     }
64098   }
64099 }
64100
64101
64102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
64103   void * jresult ;
64104   Dali::Toolkit::FlexContainer result;
64105
64106   {
64107     try {
64108       result = Dali::Toolkit::FlexContainer::New();
64109     } catch (std::out_of_range& e) {
64110       {
64111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64112       };
64113     } catch (std::exception& e) {
64114       {
64115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64116       };
64117     } catch (...) {
64118       {
64119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64120       };
64121     }
64122   }
64123   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
64124   return jresult;
64125 }
64126
64127
64128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
64129   void * jresult ;
64130   Dali::BaseHandle arg1 ;
64131   Dali::BaseHandle *argp1 ;
64132   Dali::Toolkit::FlexContainer result;
64133
64134   argp1 = (Dali::BaseHandle *)jarg1;
64135   if (!argp1) {
64136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64137     return 0;
64138   }
64139   arg1 = *argp1;
64140   {
64141     try {
64142       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
64143     } catch (std::out_of_range& e) {
64144       {
64145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64146       };
64147     } catch (std::exception& e) {
64148       {
64149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64150       };
64151     } catch (...) {
64152       {
64153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64154       };
64155     }
64156   }
64157   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
64158   return jresult;
64159 }
64160
64161
64162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
64163   int jresult ;
64164   int result;
64165
64166   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
64167   jresult = (int)result;
64168   return jresult;
64169 }
64170
64171
64172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
64173   int jresult ;
64174   int result;
64175
64176   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
64177   jresult = (int)result;
64178   return jresult;
64179 }
64180
64181
64182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
64183   int jresult ;
64184   int result;
64185
64186   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
64187   jresult = (int)result;
64188   return jresult;
64189 }
64190
64191
64192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
64193   int jresult ;
64194   int result;
64195
64196   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
64197   jresult = (int)result;
64198   return jresult;
64199 }
64200
64201
64202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
64203   void * jresult ;
64204   Dali::Toolkit::ImageView::Property *result = 0 ;
64205
64206   {
64207     try {
64208       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
64209     } catch (std::out_of_range& e) {
64210       {
64211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64212       };
64213     } catch (std::exception& e) {
64214       {
64215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64216       };
64217     } catch (...) {
64218       {
64219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64220       };
64221     }
64222   }
64223   jresult = (void *)result;
64224   return jresult;
64225 }
64226
64227
64228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
64229   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
64230
64231   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
64232   {
64233     try {
64234       delete arg1;
64235     } catch (std::out_of_range& e) {
64236       {
64237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64238       };
64239     } catch (std::exception& e) {
64240       {
64241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64242       };
64243     } catch (...) {
64244       {
64245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64246       };
64247     }
64248   }
64249 }
64250
64251
64252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
64253   void * jresult ;
64254   Dali::Toolkit::ImageView *result = 0 ;
64255
64256   {
64257     try {
64258       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
64259     } catch (std::out_of_range& e) {
64260       {
64261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64262       };
64263     } catch (std::exception& e) {
64264       {
64265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64266       };
64267     } catch (...) {
64268       {
64269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64270       };
64271     }
64272   }
64273   jresult = (void *)result;
64274   return jresult;
64275 }
64276
64277
64278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
64279   void * jresult ;
64280   Dali::Toolkit::ImageView result;
64281
64282   {
64283     try {
64284       result = Dali::Toolkit::ImageView::New();
64285     } catch (std::out_of_range& e) {
64286       {
64287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64288       };
64289     } catch (std::exception& e) {
64290       {
64291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64292       };
64293     } catch (...) {
64294       {
64295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64296       };
64297     }
64298   }
64299   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64300   return jresult;
64301 }
64302
64303
64304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
64305   void * jresult ;
64306   Dali::Image arg1 ;
64307   Dali::Image *argp1 ;
64308   Dali::Toolkit::ImageView result;
64309
64310   argp1 = (Dali::Image *)jarg1;
64311   if (!argp1) {
64312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64313     return 0;
64314   }
64315   arg1 = *argp1;
64316   {
64317     try {
64318       result = Dali::Toolkit::ImageView::New(arg1);
64319     } catch (std::out_of_range& e) {
64320       {
64321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (std::exception& e) {
64324       {
64325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64326       };
64327     } catch (...) {
64328       {
64329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64330       };
64331     }
64332   }
64333   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64334   return jresult;
64335 }
64336
64337
64338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
64339   void * jresult ;
64340   std::string *arg1 = 0 ;
64341   Dali::Toolkit::ImageView result;
64342
64343   if (!jarg1) {
64344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64345     return 0;
64346   }
64347   std::string arg1_str(jarg1);
64348   arg1 = &arg1_str;
64349   {
64350     try {
64351       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
64352     } catch (std::out_of_range& e) {
64353       {
64354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64355       };
64356     } catch (std::exception& e) {
64357       {
64358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64359       };
64360     } catch (...) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64363       };
64364     }
64365   }
64366   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64367
64368   //argout typemap for const std::string&
64369
64370   return jresult;
64371 }
64372
64373
64374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
64375   void * jresult ;
64376   std::string *arg1 = 0 ;
64377   Dali::ImageDimensions arg2 ;
64378   Dali::ImageDimensions *argp2 ;
64379   Dali::Toolkit::ImageView result;
64380
64381   if (!jarg1) {
64382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64383     return 0;
64384   }
64385   std::string arg1_str(jarg1);
64386   arg1 = &arg1_str;
64387   argp2 = (Dali::ImageDimensions *)jarg2;
64388   if (!argp2) {
64389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
64390     return 0;
64391   }
64392   arg2 = *argp2;
64393   {
64394     try {
64395       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
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 = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64411
64412   //argout typemap for const std::string&
64413
64414   return jresult;
64415 }
64416
64417
64418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
64419   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64420
64421   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64422   {
64423     try {
64424       delete arg1;
64425     } catch (std::out_of_range& e) {
64426       {
64427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64428       };
64429     } catch (std::exception& e) {
64430       {
64431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64432       };
64433     } catch (...) {
64434       {
64435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64436       };
64437     }
64438   }
64439 }
64440
64441
64442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
64443   void * jresult ;
64444   Dali::Toolkit::ImageView *arg1 = 0 ;
64445   Dali::Toolkit::ImageView *result = 0 ;
64446
64447   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64448   if (!arg1) {
64449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
64450     return 0;
64451   }
64452   {
64453     try {
64454       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
64455     } catch (std::out_of_range& e) {
64456       {
64457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64458       };
64459     } catch (std::exception& e) {
64460       {
64461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64462       };
64463     } catch (...) {
64464       {
64465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64466       };
64467     }
64468   }
64469   jresult = (void *)result;
64470   return jresult;
64471 }
64472
64473
64474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
64475   void * jresult ;
64476   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64477   Dali::Toolkit::ImageView *arg2 = 0 ;
64478   Dali::Toolkit::ImageView *result = 0 ;
64479
64480   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64481   arg2 = (Dali::Toolkit::ImageView *)jarg2;
64482   if (!arg2) {
64483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
64484     return 0;
64485   }
64486   {
64487     try {
64488       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
64489     } catch (std::out_of_range& e) {
64490       {
64491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64492       };
64493     } catch (std::exception& e) {
64494       {
64495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64496       };
64497     } catch (...) {
64498       {
64499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64500       };
64501     }
64502   }
64503   jresult = (void *)result;
64504   return jresult;
64505 }
64506
64507
64508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
64509   void * jresult ;
64510   Dali::BaseHandle arg1 ;
64511   Dali::BaseHandle *argp1 ;
64512   Dali::Toolkit::ImageView result;
64513
64514   argp1 = (Dali::BaseHandle *)jarg1;
64515   if (!argp1) {
64516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64517     return 0;
64518   }
64519   arg1 = *argp1;
64520   {
64521     try {
64522       result = Dali::Toolkit::ImageView::DownCast(arg1);
64523     } catch (std::out_of_range& e) {
64524       {
64525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64526       };
64527     } catch (std::exception& e) {
64528       {
64529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64530       };
64531     } catch (...) {
64532       {
64533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64534       };
64535     }
64536   }
64537   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64538   return jresult;
64539 }
64540
64541
64542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
64543   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64544   Dali::Image arg2 ;
64545   Dali::Image *argp2 ;
64546
64547   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64548   argp2 = (Dali::Image *)jarg2;
64549   if (!argp2) {
64550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64551     return ;
64552   }
64553   arg2 = *argp2;
64554   {
64555     try {
64556       (arg1)->SetImage(arg2);
64557     } catch (std::out_of_range& e) {
64558       {
64559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64560       };
64561     } catch (std::exception& e) {
64562       {
64563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64564       };
64565     } catch (...) {
64566       {
64567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64568       };
64569     }
64570   }
64571 }
64572
64573
64574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
64575   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64576   std::string *arg2 = 0 ;
64577
64578   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64579   if (!jarg2) {
64580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64581     return ;
64582   }
64583   std::string arg2_str(jarg2);
64584   arg2 = &arg2_str;
64585   {
64586     try {
64587       (arg1)->SetImage((std::string const &)*arg2);
64588     } catch (std::out_of_range& e) {
64589       {
64590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64591       };
64592     } catch (std::exception& e) {
64593       {
64594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64595       };
64596     } catch (...) {
64597       {
64598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64599       };
64600     }
64601   }
64602
64603   //argout typemap for const std::string&
64604
64605 }
64606
64607
64608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
64609   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64610   std::string *arg2 = 0 ;
64611   Dali::ImageDimensions arg3 ;
64612   Dali::ImageDimensions *argp3 ;
64613
64614   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64615   if (!jarg2) {
64616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64617     return ;
64618   }
64619   std::string arg2_str(jarg2);
64620   arg2 = &arg2_str;
64621   argp3 = (Dali::ImageDimensions *)jarg3;
64622   if (!argp3) {
64623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
64624     return ;
64625   }
64626   arg3 = *argp3;
64627   {
64628     try {
64629       (arg1)->SetImage((std::string const &)*arg2,arg3);
64630     } catch (std::out_of_range& e) {
64631       {
64632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64633       };
64634     } catch (std::exception& e) {
64635       {
64636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64637       };
64638     } catch (...) {
64639       {
64640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64641       };
64642     }
64643   }
64644
64645   //argout typemap for const std::string&
64646
64647 }
64648
64649
64650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
64651   void * jresult ;
64652   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64653   Dali::Image result;
64654
64655   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64656   {
64657     try {
64658       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
64659     } catch (std::out_of_range& e) {
64660       {
64661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64662       };
64663     } catch (std::exception& e) {
64664       {
64665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64666       };
64667     } catch (...) {
64668       {
64669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64670       };
64671     }
64672   }
64673   jresult = new Dali::Image((const Dali::Image &)result);
64674   return jresult;
64675 }
64676
64677
64678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
64679   int jresult ;
64680   int result;
64681
64682   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
64683   jresult = (int)result;
64684   return jresult;
64685 }
64686
64687
64688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
64689   int jresult ;
64690   int result;
64691
64692   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
64693   jresult = (int)result;
64694   return jresult;
64695 }
64696
64697
64698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
64699   int jresult ;
64700   int result;
64701
64702   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
64703   jresult = (int)result;
64704   return jresult;
64705 }
64706
64707
64708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
64709   int jresult ;
64710   int result;
64711
64712   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
64713   jresult = (int)result;
64714   return jresult;
64715 }
64716
64717
64718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
64719   int jresult ;
64720   int result;
64721
64722   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
64723   jresult = (int)result;
64724   return jresult;
64725 }
64726
64727
64728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
64729   int jresult ;
64730   int result;
64731
64732   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
64733   jresult = (int)result;
64734   return jresult;
64735 }
64736
64737
64738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
64739   int jresult ;
64740   int result;
64741
64742   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
64743   jresult = (int)result;
64744   return jresult;
64745 }
64746
64747
64748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
64749   int jresult ;
64750   int result;
64751
64752   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
64753   jresult = (int)result;
64754   return jresult;
64755 }
64756
64757
64758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
64759   void * jresult ;
64760   Dali::Toolkit::Model3dView::Property *result = 0 ;
64761
64762   {
64763     try {
64764       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
64765     } catch (std::out_of_range& e) {
64766       {
64767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64768       };
64769     } catch (std::exception& e) {
64770       {
64771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64772       };
64773     } catch (...) {
64774       {
64775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64776       };
64777     }
64778   }
64779   jresult = (void *)result;
64780   return jresult;
64781 }
64782
64783
64784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
64785   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
64786
64787   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
64788   {
64789     try {
64790       delete arg1;
64791     } catch (std::out_of_range& e) {
64792       {
64793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64794       };
64795     } catch (std::exception& e) {
64796       {
64797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64798       };
64799     } catch (...) {
64800       {
64801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64802       };
64803     }
64804   }
64805 }
64806
64807
64808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
64809   void * jresult ;
64810   Dali::Toolkit::Model3dView result;
64811
64812   {
64813     try {
64814       result = Dali::Toolkit::Model3dView::New();
64815     } catch (std::out_of_range& e) {
64816       {
64817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64818       };
64819     } catch (std::exception& e) {
64820       {
64821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64822       };
64823     } catch (...) {
64824       {
64825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64826       };
64827     }
64828   }
64829   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64830   return jresult;
64831 }
64832
64833
64834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
64835   void * jresult ;
64836   std::string *arg1 = 0 ;
64837   std::string *arg2 = 0 ;
64838   std::string *arg3 = 0 ;
64839   Dali::Toolkit::Model3dView result;
64840
64841   if (!jarg1) {
64842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64843     return 0;
64844   }
64845   std::string arg1_str(jarg1);
64846   arg1 = &arg1_str;
64847   if (!jarg2) {
64848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64849     return 0;
64850   }
64851   std::string arg2_str(jarg2);
64852   arg2 = &arg2_str;
64853   if (!jarg3) {
64854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64855     return 0;
64856   }
64857   std::string arg3_str(jarg3);
64858   arg3 = &arg3_str;
64859   {
64860     try {
64861       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
64862     } catch (std::out_of_range& e) {
64863       {
64864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64865       };
64866     } catch (std::exception& e) {
64867       {
64868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64869       };
64870     } catch (...) {
64871       {
64872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64873       };
64874     }
64875   }
64876   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64877
64878   //argout typemap for const std::string&
64879
64880
64881   //argout typemap for const std::string&
64882
64883
64884   //argout typemap for const std::string&
64885
64886   return jresult;
64887 }
64888
64889
64890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
64891   void * jresult ;
64892   Dali::Toolkit::Model3dView *result = 0 ;
64893
64894   {
64895     try {
64896       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
64897     } catch (std::out_of_range& e) {
64898       {
64899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64900       };
64901     } catch (std::exception& e) {
64902       {
64903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64904       };
64905     } catch (...) {
64906       {
64907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64908       };
64909     }
64910   }
64911   jresult = (void *)result;
64912   return jresult;
64913 }
64914
64915
64916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
64917   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
64918
64919   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64920   {
64921     try {
64922       delete arg1;
64923     } catch (std::out_of_range& e) {
64924       {
64925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64926       };
64927     } catch (std::exception& e) {
64928       {
64929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64930       };
64931     } catch (...) {
64932       {
64933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64934       };
64935     }
64936   }
64937 }
64938
64939
64940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
64941   void * jresult ;
64942   Dali::Toolkit::Model3dView *arg1 = 0 ;
64943   Dali::Toolkit::Model3dView *result = 0 ;
64944
64945   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64946   if (!arg1) {
64947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
64948     return 0;
64949   }
64950   {
64951     try {
64952       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
64953     } catch (std::out_of_range& e) {
64954       {
64955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64956       };
64957     } catch (std::exception& e) {
64958       {
64959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64960       };
64961     } catch (...) {
64962       {
64963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64964       };
64965     }
64966   }
64967   jresult = (void *)result;
64968   return jresult;
64969 }
64970
64971
64972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
64973   void * jresult ;
64974   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
64975   Dali::Toolkit::Model3dView *arg2 = 0 ;
64976   Dali::Toolkit::Model3dView *result = 0 ;
64977
64978   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64979   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
64980   if (!arg2) {
64981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
64982     return 0;
64983   }
64984   {
64985     try {
64986       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
64987     } catch (std::out_of_range& e) {
64988       {
64989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64990       };
64991     } catch (std::exception& e) {
64992       {
64993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64994       };
64995     } catch (...) {
64996       {
64997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64998       };
64999     }
65000   }
65001   jresult = (void *)result;
65002   return jresult;
65003 }
65004
65005
65006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
65007   void * jresult ;
65008   Dali::BaseHandle arg1 ;
65009   Dali::BaseHandle *argp1 ;
65010   Dali::Toolkit::Model3dView result;
65011
65012   argp1 = (Dali::BaseHandle *)jarg1;
65013   if (!argp1) {
65014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65015     return 0;
65016   }
65017   arg1 = *argp1;
65018   {
65019     try {
65020       result = Dali::Toolkit::Model3dView::DownCast(arg1);
65021     } catch (std::out_of_range& e) {
65022       {
65023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65024       };
65025     } catch (std::exception& e) {
65026       {
65027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65028       };
65029     } catch (...) {
65030       {
65031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65032       };
65033     }
65034   }
65035   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
65036   return jresult;
65037 }
65038
65039
65040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
65041   int jresult ;
65042   int result;
65043
65044   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
65045   jresult = (int)result;
65046   return jresult;
65047 }
65048
65049
65050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
65051   int jresult ;
65052   int result;
65053
65054   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
65055   jresult = (int)result;
65056   return jresult;
65057 }
65058
65059
65060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
65061   int jresult ;
65062   int result;
65063
65064   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
65065   jresult = (int)result;
65066   return jresult;
65067 }
65068
65069
65070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
65071   int jresult ;
65072   int result;
65073
65074   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
65075   jresult = (int)result;
65076   return jresult;
65077 }
65078
65079
65080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
65081   int jresult ;
65082   int result;
65083
65084   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
65085   jresult = (int)result;
65086   return jresult;
65087 }
65088
65089
65090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
65091   int jresult ;
65092   int result;
65093
65094   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
65095   jresult = (int)result;
65096   return jresult;
65097 }
65098
65099
65100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
65101   int jresult ;
65102   int result;
65103
65104   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
65105   jresult = (int)result;
65106   return jresult;
65107 }
65108
65109
65110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
65111   int jresult ;
65112   int result;
65113
65114   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
65115   jresult = (int)result;
65116   return jresult;
65117 }
65118
65119
65120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
65121   int jresult ;
65122   int result;
65123
65124   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
65125   jresult = (int)result;
65126   return jresult;
65127 }
65128
65129
65130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
65131   void * jresult ;
65132   Dali::Toolkit::ScrollBar::Property *result = 0 ;
65133
65134   {
65135     try {
65136       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
65137     } catch (std::out_of_range& e) {
65138       {
65139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65140       };
65141     } catch (std::exception& e) {
65142       {
65143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65144       };
65145     } catch (...) {
65146       {
65147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65148       };
65149     }
65150   }
65151   jresult = (void *)result;
65152   return jresult;
65153 }
65154
65155
65156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
65157   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
65158
65159   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
65160   {
65161     try {
65162       delete arg1;
65163     } catch (std::out_of_range& e) {
65164       {
65165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65166       };
65167     } catch (std::exception& e) {
65168       {
65169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65170       };
65171     } catch (...) {
65172       {
65173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65174       };
65175     }
65176   }
65177 }
65178
65179
65180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
65181   void * jresult ;
65182   Dali::Toolkit::ScrollBar *result = 0 ;
65183
65184   {
65185     try {
65186       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
65187     } catch (std::out_of_range& e) {
65188       {
65189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65190       };
65191     } catch (std::exception& e) {
65192       {
65193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65194       };
65195     } catch (...) {
65196       {
65197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65198       };
65199     }
65200   }
65201   jresult = (void *)result;
65202   return jresult;
65203 }
65204
65205
65206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
65207   void * jresult ;
65208   Dali::Toolkit::ScrollBar *arg1 = 0 ;
65209   Dali::Toolkit::ScrollBar *result = 0 ;
65210
65211   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65212   if (!arg1) {
65213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
65214     return 0;
65215   }
65216   {
65217     try {
65218       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
65219     } catch (std::out_of_range& e) {
65220       {
65221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65222       };
65223     } catch (std::exception& e) {
65224       {
65225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (...) {
65228       {
65229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65230       };
65231     }
65232   }
65233   jresult = (void *)result;
65234   return jresult;
65235 }
65236
65237
65238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
65239   void * jresult ;
65240   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65241   Dali::Toolkit::ScrollBar *arg2 = 0 ;
65242   Dali::Toolkit::ScrollBar *result = 0 ;
65243
65244   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65245   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
65246   if (!arg2) {
65247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
65248     return 0;
65249   }
65250   {
65251     try {
65252       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
65253     } catch (std::out_of_range& e) {
65254       {
65255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (std::exception& e) {
65258       {
65259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (...) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65264       };
65265     }
65266   }
65267   jresult = (void *)result;
65268   return jresult;
65269 }
65270
65271
65272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
65273   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65274
65275   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65276   {
65277     try {
65278       delete arg1;
65279     } catch (std::out_of_range& e) {
65280       {
65281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65282       };
65283     } catch (std::exception& e) {
65284       {
65285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65286       };
65287     } catch (...) {
65288       {
65289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65290       };
65291     }
65292   }
65293 }
65294
65295
65296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
65297   void * jresult ;
65298   Dali::Toolkit::ScrollBar::Direction arg1 ;
65299   Dali::Toolkit::ScrollBar result;
65300
65301   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
65302   {
65303     try {
65304       result = Dali::Toolkit::ScrollBar::New(arg1);
65305     } catch (std::out_of_range& e) {
65306       {
65307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65308       };
65309     } catch (std::exception& e) {
65310       {
65311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (...) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65316       };
65317     }
65318   }
65319   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65320   return jresult;
65321 }
65322
65323
65324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
65325   void * jresult ;
65326   Dali::Toolkit::ScrollBar result;
65327
65328   {
65329     try {
65330       result = Dali::Toolkit::ScrollBar::New();
65331     } catch (std::out_of_range& e) {
65332       {
65333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65334       };
65335     } catch (std::exception& e) {
65336       {
65337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65338       };
65339     } catch (...) {
65340       {
65341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65342       };
65343     }
65344   }
65345   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65346   return jresult;
65347 }
65348
65349
65350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
65351   void * jresult ;
65352   Dali::BaseHandle arg1 ;
65353   Dali::BaseHandle *argp1 ;
65354   Dali::Toolkit::ScrollBar result;
65355
65356   argp1 = (Dali::BaseHandle *)jarg1;
65357   if (!argp1) {
65358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65359     return 0;
65360   }
65361   arg1 = *argp1;
65362   {
65363     try {
65364       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
65365     } catch (std::out_of_range& e) {
65366       {
65367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65368       };
65369     } catch (std::exception& e) {
65370       {
65371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65372       };
65373     } catch (...) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65376       };
65377     }
65378   }
65379   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65380   return jresult;
65381 }
65382
65383
65384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
65385   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65386   Dali::Handle arg2 ;
65387   Dali::Property::Index arg3 ;
65388   Dali::Property::Index arg4 ;
65389   Dali::Property::Index arg5 ;
65390   Dali::Property::Index arg6 ;
65391   Dali::Handle *argp2 ;
65392
65393   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65394   argp2 = (Dali::Handle *)jarg2;
65395   if (!argp2) {
65396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
65397     return ;
65398   }
65399   arg2 = *argp2;
65400   arg3 = (Dali::Property::Index)jarg3;
65401   arg4 = (Dali::Property::Index)jarg4;
65402   arg5 = (Dali::Property::Index)jarg5;
65403   arg6 = (Dali::Property::Index)jarg6;
65404   {
65405     try {
65406       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
65407     } catch (std::out_of_range& e) {
65408       {
65409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65410       };
65411     } catch (std::exception& e) {
65412       {
65413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65414       };
65415     } catch (...) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65418       };
65419     }
65420   }
65421 }
65422
65423
65424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
65425   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65426   Dali::Actor arg2 ;
65427   Dali::Actor *argp2 ;
65428
65429   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65430   argp2 = (Dali::Actor *)jarg2;
65431   if (!argp2) {
65432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65433     return ;
65434   }
65435   arg2 = *argp2;
65436   {
65437     try {
65438       (arg1)->SetScrollIndicator(arg2);
65439     } catch (std::out_of_range& e) {
65440       {
65441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65442       };
65443     } catch (std::exception& e) {
65444       {
65445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65446       };
65447     } catch (...) {
65448       {
65449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65450       };
65451     }
65452   }
65453 }
65454
65455
65456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
65457   void * jresult ;
65458   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65459   Dali::Actor result;
65460
65461   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65462   {
65463     try {
65464       result = (arg1)->GetScrollIndicator();
65465     } catch (std::out_of_range& e) {
65466       {
65467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65468       };
65469     } catch (std::exception& e) {
65470       {
65471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65472       };
65473     } catch (...) {
65474       {
65475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65476       };
65477     }
65478   }
65479   jresult = new Dali::Actor((const Dali::Actor &)result);
65480   return jresult;
65481 }
65482
65483
65484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
65485   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65486   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
65487
65488   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65489   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
65490   if (!arg2) {
65491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
65492     return ;
65493   }
65494   {
65495     try {
65496       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
65497     } catch (std::out_of_range& e) {
65498       {
65499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65500       };
65501     } catch (std::exception& e) {
65502       {
65503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65504       };
65505     } catch (...) {
65506       {
65507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65508       };
65509     }
65510   }
65511 }
65512
65513
65514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
65515   void * jresult ;
65516   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65517   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
65518
65519   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65520   {
65521     try {
65522       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
65523     } catch (std::out_of_range& e) {
65524       {
65525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65526       };
65527     } catch (std::exception& e) {
65528       {
65529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65530       };
65531     } catch (...) {
65532       {
65533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65534       };
65535     }
65536   }
65537   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
65538   return jresult;
65539 }
65540
65541
65542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
65543   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65544   Dali::Toolkit::ScrollBar::Direction arg2 ;
65545
65546   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65547   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
65548   {
65549     try {
65550       (arg1)->SetScrollDirection(arg2);
65551     } catch (std::out_of_range& e) {
65552       {
65553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65554       };
65555     } catch (std::exception& e) {
65556       {
65557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65558       };
65559     } catch (...) {
65560       {
65561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65562       };
65563     }
65564   }
65565 }
65566
65567
65568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
65569   int jresult ;
65570   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65571   Dali::Toolkit::ScrollBar::Direction result;
65572
65573   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65574   {
65575     try {
65576       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
65577     } catch (std::out_of_range& e) {
65578       {
65579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (std::exception& e) {
65582       {
65583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65584       };
65585     } catch (...) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65588       };
65589     }
65590   }
65591   jresult = (int)result;
65592   return jresult;
65593 }
65594
65595
65596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
65597   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65598   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
65599
65600   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65601   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
65602   {
65603     try {
65604       (arg1)->SetIndicatorHeightPolicy(arg2);
65605     } catch (std::out_of_range& e) {
65606       {
65607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65608       };
65609     } catch (std::exception& e) {
65610       {
65611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65612       };
65613     } catch (...) {
65614       {
65615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65616       };
65617     }
65618   }
65619 }
65620
65621
65622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
65623   int jresult ;
65624   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65625   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
65626
65627   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65628   {
65629     try {
65630       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
65631     } catch (std::out_of_range& e) {
65632       {
65633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65634       };
65635     } catch (std::exception& e) {
65636       {
65637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65638       };
65639     } catch (...) {
65640       {
65641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65642       };
65643     }
65644   }
65645   jresult = (int)result;
65646   return jresult;
65647 }
65648
65649
65650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
65651   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65652   float arg2 ;
65653
65654   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65655   arg2 = (float)jarg2;
65656   {
65657     try {
65658       (arg1)->SetIndicatorFixedHeight(arg2);
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65670       };
65671     }
65672   }
65673 }
65674
65675
65676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
65677   float jresult ;
65678   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65679   float result;
65680
65681   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65682   {
65683     try {
65684       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
65685     } catch (std::out_of_range& e) {
65686       {
65687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65688       };
65689     } catch (std::exception& e) {
65690       {
65691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65692       };
65693     } catch (...) {
65694       {
65695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65696       };
65697     }
65698   }
65699   jresult = result;
65700   return jresult;
65701 }
65702
65703
65704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
65705   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65706   float arg2 ;
65707
65708   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65709   arg2 = (float)jarg2;
65710   {
65711     try {
65712       (arg1)->SetIndicatorShowDuration(arg2);
65713     } catch (std::out_of_range& e) {
65714       {
65715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65716       };
65717     } catch (std::exception& e) {
65718       {
65719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65720       };
65721     } catch (...) {
65722       {
65723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65724       };
65725     }
65726   }
65727 }
65728
65729
65730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
65731   float jresult ;
65732   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65733   float result;
65734
65735   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65736   {
65737     try {
65738       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
65739     } catch (std::out_of_range& e) {
65740       {
65741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65742       };
65743     } catch (std::exception& e) {
65744       {
65745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65746       };
65747     } catch (...) {
65748       {
65749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65750       };
65751     }
65752   }
65753   jresult = result;
65754   return jresult;
65755 }
65756
65757
65758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
65759   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65760   float arg2 ;
65761
65762   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65763   arg2 = (float)jarg2;
65764   {
65765     try {
65766       (arg1)->SetIndicatorHideDuration(arg2);
65767     } catch (std::out_of_range& e) {
65768       {
65769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65770       };
65771     } catch (std::exception& e) {
65772       {
65773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65774       };
65775     } catch (...) {
65776       {
65777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65778       };
65779     }
65780   }
65781 }
65782
65783
65784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
65785   float jresult ;
65786   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65787   float result;
65788
65789   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65790   {
65791     try {
65792       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
65793     } catch (std::out_of_range& e) {
65794       {
65795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65796       };
65797     } catch (std::exception& e) {
65798       {
65799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65800       };
65801     } catch (...) {
65802       {
65803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65804       };
65805     }
65806   }
65807   jresult = result;
65808   return jresult;
65809 }
65810
65811
65812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
65813   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65814
65815   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65816   {
65817     try {
65818       (arg1)->ShowIndicator();
65819     } catch (std::out_of_range& e) {
65820       {
65821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65822       };
65823     } catch (std::exception& e) {
65824       {
65825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65826       };
65827     } catch (...) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65830       };
65831     }
65832   }
65833 }
65834
65835
65836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
65837   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65838
65839   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65840   {
65841     try {
65842       (arg1)->HideIndicator();
65843     } catch (std::out_of_range& e) {
65844       {
65845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65846       };
65847     } catch (std::exception& e) {
65848       {
65849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65850       };
65851     } catch (...) {
65852       {
65853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65854       };
65855     }
65856   }
65857 }
65858
65859
65860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
65861   void * jresult ;
65862   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65863   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
65864
65865   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65866   {
65867     try {
65868       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
65869     } catch (std::out_of_range& e) {
65870       {
65871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65872       };
65873     } catch (std::exception& e) {
65874       {
65875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65876       };
65877     } catch (...) {
65878       {
65879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65880       };
65881     }
65882   }
65883   jresult = (void *)result;
65884   return jresult;
65885 }
65886
65887
65888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
65889   void * jresult ;
65890   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65891   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
65892
65893   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65894   {
65895     try {
65896       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
65897     } catch (std::out_of_range& e) {
65898       {
65899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65900       };
65901     } catch (std::exception& e) {
65902       {
65903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65904       };
65905     } catch (...) {
65906       {
65907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65908       };
65909     }
65910   }
65911   jresult = (void *)result;
65912   return jresult;
65913 }
65914
65915
65916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
65917   int jresult ;
65918   int result;
65919
65920   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
65921   jresult = (int)result;
65922   return jresult;
65923 }
65924
65925
65926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
65927   int jresult ;
65928   int result;
65929
65930   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
65931   jresult = (int)result;
65932   return jresult;
65933 }
65934
65935
65936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
65937   int jresult ;
65938   int result;
65939
65940   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
65941   jresult = (int)result;
65942   return jresult;
65943 }
65944
65945
65946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
65947   int jresult ;
65948   int result;
65949
65950   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
65951   jresult = (int)result;
65952   return jresult;
65953 }
65954
65955
65956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
65957   int jresult ;
65958   int result;
65959
65960   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
65961   jresult = (int)result;
65962   return jresult;
65963 }
65964
65965
65966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
65967   int jresult ;
65968   int result;
65969
65970   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
65971   jresult = (int)result;
65972   return jresult;
65973 }
65974
65975
65976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
65977   int jresult ;
65978   int result;
65979
65980   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
65981   jresult = (int)result;
65982   return jresult;
65983 }
65984
65985
65986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
65987   int jresult ;
65988   int result;
65989
65990   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
65991   jresult = (int)result;
65992   return jresult;
65993 }
65994
65995
65996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
65997   int jresult ;
65998   int result;
65999
66000   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
66001   jresult = (int)result;
66002   return jresult;
66003 }
66004
66005
66006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
66007   int jresult ;
66008   int result;
66009
66010   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
66011   jresult = (int)result;
66012   return jresult;
66013 }
66014
66015
66016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
66017   int jresult ;
66018   int result;
66019
66020   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
66021   jresult = (int)result;
66022   return jresult;
66023 }
66024
66025
66026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
66027   int jresult ;
66028   int result;
66029
66030   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
66031   jresult = (int)result;
66032   return jresult;
66033 }
66034
66035
66036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
66037   int jresult ;
66038   int result;
66039
66040   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
66041   jresult = (int)result;
66042   return jresult;
66043 }
66044
66045
66046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
66047   int jresult ;
66048   int result;
66049
66050   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
66051   jresult = (int)result;
66052   return jresult;
66053 }
66054
66055
66056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
66057   void * jresult ;
66058   Dali::Toolkit::Scrollable::Property *result = 0 ;
66059
66060   {
66061     try {
66062       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
66063     } catch (std::out_of_range& e) {
66064       {
66065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66066       };
66067     } catch (std::exception& e) {
66068       {
66069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66070       };
66071     } catch (...) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66074       };
66075     }
66076   }
66077   jresult = (void *)result;
66078   return jresult;
66079 }
66080
66081
66082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
66083   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
66084
66085   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
66086   {
66087     try {
66088       delete arg1;
66089     } catch (std::out_of_range& e) {
66090       {
66091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66092       };
66093     } catch (std::exception& e) {
66094       {
66095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66096       };
66097     } catch (...) {
66098       {
66099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66100       };
66101     }
66102   }
66103 }
66104
66105
66106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
66107   void * jresult ;
66108   Dali::Toolkit::Scrollable *result = 0 ;
66109
66110   {
66111     try {
66112       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
66113     } catch (std::out_of_range& e) {
66114       {
66115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66116       };
66117     } catch (std::exception& e) {
66118       {
66119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66120       };
66121     } catch (...) {
66122       {
66123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66124       };
66125     }
66126   }
66127   jresult = (void *)result;
66128   return jresult;
66129 }
66130
66131
66132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
66133   void * jresult ;
66134   Dali::Toolkit::Scrollable *arg1 = 0 ;
66135   Dali::Toolkit::Scrollable *result = 0 ;
66136
66137   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66138   if (!arg1) {
66139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
66140     return 0;
66141   }
66142   {
66143     try {
66144       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
66145     } catch (std::out_of_range& e) {
66146       {
66147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66148       };
66149     } catch (std::exception& e) {
66150       {
66151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66152       };
66153     } catch (...) {
66154       {
66155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66156       };
66157     }
66158   }
66159   jresult = (void *)result;
66160   return jresult;
66161 }
66162
66163
66164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
66165   void * jresult ;
66166   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66167   Dali::Toolkit::Scrollable *arg2 = 0 ;
66168   Dali::Toolkit::Scrollable *result = 0 ;
66169
66170   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66171   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
66172   if (!arg2) {
66173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
66174     return 0;
66175   }
66176   {
66177     try {
66178       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
66179     } catch (std::out_of_range& e) {
66180       {
66181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66182       };
66183     } catch (std::exception& e) {
66184       {
66185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66186       };
66187     } catch (...) {
66188       {
66189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66190       };
66191     }
66192   }
66193   jresult = (void *)result;
66194   return jresult;
66195 }
66196
66197
66198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
66199   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66200
66201   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66202   {
66203     try {
66204       delete arg1;
66205     } catch (std::out_of_range& e) {
66206       {
66207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66208       };
66209     } catch (std::exception& e) {
66210       {
66211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66212       };
66213     } catch (...) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66216       };
66217     }
66218   }
66219 }
66220
66221
66222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
66223   void * jresult ;
66224   Dali::BaseHandle arg1 ;
66225   Dali::BaseHandle *argp1 ;
66226   Dali::Toolkit::Scrollable result;
66227
66228   argp1 = (Dali::BaseHandle *)jarg1;
66229   if (!argp1) {
66230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66231     return 0;
66232   }
66233   arg1 = *argp1;
66234   {
66235     try {
66236       result = Dali::Toolkit::Scrollable::DownCast(arg1);
66237     } catch (std::out_of_range& e) {
66238       {
66239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66240       };
66241     } catch (std::exception& e) {
66242       {
66243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66244       };
66245     } catch (...) {
66246       {
66247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66248       };
66249     }
66250   }
66251   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
66252   return jresult;
66253 }
66254
66255
66256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
66257   unsigned int jresult ;
66258   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66259   bool result;
66260
66261   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66262   {
66263     try {
66264       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
66265     } catch (std::out_of_range& e) {
66266       {
66267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66268       };
66269     } catch (std::exception& e) {
66270       {
66271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66272       };
66273     } catch (...) {
66274       {
66275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66276       };
66277     }
66278   }
66279   jresult = result;
66280   return jresult;
66281 }
66282
66283
66284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
66285   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66286   bool arg2 ;
66287
66288   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66289   arg2 = jarg2 ? true : false;
66290   {
66291     try {
66292       (arg1)->SetOvershootEnabled(arg2);
66293     } catch (std::out_of_range& e) {
66294       {
66295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66296       };
66297     } catch (std::exception& e) {
66298       {
66299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66300       };
66301     } catch (...) {
66302       {
66303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66304       };
66305     }
66306   }
66307 }
66308
66309
66310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
66311   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66312   Dali::Vector4 *arg2 = 0 ;
66313
66314   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66315   arg2 = (Dali::Vector4 *)jarg2;
66316   if (!arg2) {
66317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
66318     return ;
66319   }
66320   {
66321     try {
66322       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
66323     } catch (std::out_of_range& e) {
66324       {
66325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66326       };
66327     } catch (std::exception& e) {
66328       {
66329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66330       };
66331     } catch (...) {
66332       {
66333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66334       };
66335     }
66336   }
66337 }
66338
66339
66340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
66341   void * jresult ;
66342   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66343   Dali::Vector4 result;
66344
66345   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66346   {
66347     try {
66348       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
66349     } catch (std::out_of_range& e) {
66350       {
66351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66352       };
66353     } catch (std::exception& e) {
66354       {
66355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66356       };
66357     } catch (...) {
66358       {
66359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66360       };
66361     }
66362   }
66363   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
66364   return jresult;
66365 }
66366
66367
66368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
66369   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66370   float arg2 ;
66371
66372   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66373   arg2 = (float)jarg2;
66374   {
66375     try {
66376       (arg1)->SetOvershootAnimationSpeed(arg2);
66377     } catch (std::out_of_range& e) {
66378       {
66379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66380       };
66381     } catch (std::exception& e) {
66382       {
66383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66384       };
66385     } catch (...) {
66386       {
66387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66388       };
66389     }
66390   }
66391 }
66392
66393
66394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
66395   float jresult ;
66396   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66397   float result;
66398
66399   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66400   {
66401     try {
66402       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
66403     } catch (std::out_of_range& e) {
66404       {
66405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66406       };
66407     } catch (std::exception& e) {
66408       {
66409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66414       };
66415     }
66416   }
66417   jresult = result;
66418   return jresult;
66419 }
66420
66421
66422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
66423   void * jresult ;
66424   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66425   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
66426
66427   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66428   {
66429     try {
66430       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
66431     } catch (std::out_of_range& e) {
66432       {
66433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66434       };
66435     } catch (std::exception& e) {
66436       {
66437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66438       };
66439     } catch (...) {
66440       {
66441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66442       };
66443     }
66444   }
66445   jresult = (void *)result;
66446   return jresult;
66447 }
66448
66449
66450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
66451   void * jresult ;
66452   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66453   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
66454
66455   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66456   {
66457     try {
66458       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
66459     } catch (std::out_of_range& e) {
66460       {
66461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66462       };
66463     } catch (std::exception& e) {
66464       {
66465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66466       };
66467     } catch (...) {
66468       {
66469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66470       };
66471     }
66472   }
66473   jresult = (void *)result;
66474   return jresult;
66475 }
66476
66477
66478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
66479   void * jresult ;
66480   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66481   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
66482
66483   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66484   {
66485     try {
66486       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
66487     } catch (std::out_of_range& e) {
66488       {
66489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66490       };
66491     } catch (std::exception& e) {
66492       {
66493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66494       };
66495     } catch (...) {
66496       {
66497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66498       };
66499     }
66500   }
66501   jresult = (void *)result;
66502   return jresult;
66503 }
66504
66505
66506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
66507   unsigned int jresult ;
66508   Dali::Toolkit::ControlOrientation::Type arg1 ;
66509   bool result;
66510
66511   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
66512   {
66513     try {
66514       result = (bool)Dali::Toolkit::IsVertical(arg1);
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66526       };
66527     }
66528   }
66529   jresult = result;
66530   return jresult;
66531 }
66532
66533
66534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
66535   unsigned int jresult ;
66536   Dali::Toolkit::ControlOrientation::Type arg1 ;
66537   bool result;
66538
66539   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
66540   {
66541     try {
66542       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
66543     } catch (std::out_of_range& e) {
66544       {
66545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66546       };
66547     } catch (std::exception& e) {
66548       {
66549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66550       };
66551     } catch (...) {
66552       {
66553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66554       };
66555     }
66556   }
66557   jresult = result;
66558   return jresult;
66559 }
66560
66561
66562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
66563   void * jresult ;
66564   unsigned int arg1 ;
66565   unsigned int arg2 ;
66566   Dali::Toolkit::ItemRange *result = 0 ;
66567
66568   arg1 = (unsigned int)jarg1;
66569   arg2 = (unsigned int)jarg2;
66570   {
66571     try {
66572       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
66573     } catch (std::out_of_range& e) {
66574       {
66575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66576       };
66577     } catch (std::exception& e) {
66578       {
66579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66580       };
66581     } catch (...) {
66582       {
66583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66584       };
66585     }
66586   }
66587   jresult = (void *)result;
66588   return jresult;
66589 }
66590
66591
66592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
66593   void * jresult ;
66594   Dali::Toolkit::ItemRange *arg1 = 0 ;
66595   Dali::Toolkit::ItemRange *result = 0 ;
66596
66597   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66598   if (!arg1) {
66599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66600     return 0;
66601   }
66602   {
66603     try {
66604       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
66605     } catch (std::out_of_range& e) {
66606       {
66607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66608       };
66609     } catch (std::exception& e) {
66610       {
66611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66612       };
66613     } catch (...) {
66614       {
66615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66616       };
66617     }
66618   }
66619   jresult = (void *)result;
66620   return jresult;
66621 }
66622
66623
66624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
66625   void * jresult ;
66626   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66627   Dali::Toolkit::ItemRange *arg2 = 0 ;
66628   Dali::Toolkit::ItemRange *result = 0 ;
66629
66630   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66631   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66632   if (!arg2) {
66633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66634     return 0;
66635   }
66636   {
66637     try {
66638       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
66639     } catch (std::out_of_range& e) {
66640       {
66641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66642       };
66643     } catch (std::exception& e) {
66644       {
66645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66646       };
66647     } catch (...) {
66648       {
66649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66650       };
66651     }
66652   }
66653   jresult = (void *)result;
66654   return jresult;
66655 }
66656
66657
66658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
66659   unsigned int jresult ;
66660   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66661   unsigned int arg2 ;
66662   bool result;
66663
66664   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66665   arg2 = (unsigned int)jarg2;
66666   {
66667     try {
66668       result = (bool)(arg1)->Within(arg2);
66669     } catch (std::out_of_range& e) {
66670       {
66671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66672       };
66673     } catch (std::exception& e) {
66674       {
66675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66676       };
66677     } catch (...) {
66678       {
66679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66680       };
66681     }
66682   }
66683   jresult = result;
66684   return jresult;
66685 }
66686
66687
66688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
66689   void * jresult ;
66690   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66691   Dali::Toolkit::ItemRange *arg2 = 0 ;
66692   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
66693
66694   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66695   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66696   if (!arg2) {
66697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66698     return 0;
66699   }
66700   {
66701     try {
66702       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
66703     } catch (std::out_of_range& e) {
66704       {
66705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66706       };
66707     } catch (std::exception& e) {
66708       {
66709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66710       };
66711     } catch (...) {
66712       {
66713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66714       };
66715     }
66716   }
66717   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
66718   return jresult;
66719 }
66720
66721
66722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
66723   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66724   unsigned int arg2 ;
66725
66726   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66727   arg2 = (unsigned int)jarg2;
66728   if (arg1) (arg1)->begin = arg2;
66729 }
66730
66731
66732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
66733   unsigned int jresult ;
66734   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66735   unsigned int result;
66736
66737   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66738   result = (unsigned int) ((arg1)->begin);
66739   jresult = result;
66740   return jresult;
66741 }
66742
66743
66744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
66745   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66746   unsigned int arg2 ;
66747
66748   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66749   arg2 = (unsigned int)jarg2;
66750   if (arg1) (arg1)->end = arg2;
66751 }
66752
66753
66754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
66755   unsigned int jresult ;
66756   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66757   unsigned int result;
66758
66759   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66760   result = (unsigned int) ((arg1)->end);
66761   jresult = result;
66762   return jresult;
66763 }
66764
66765
66766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
66767   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66768
66769   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66770   {
66771     try {
66772       delete arg1;
66773     } catch (std::out_of_range& e) {
66774       {
66775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66776       };
66777     } catch (std::exception& e) {
66778       {
66779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66780       };
66781     } catch (...) {
66782       {
66783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66784       };
66785     }
66786   }
66787 }
66788
66789
66790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
66791   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66792
66793   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66794   {
66795     try {
66796       delete arg1;
66797     } catch (std::out_of_range& e) {
66798       {
66799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66800       };
66801     } catch (std::exception& e) {
66802       {
66803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66804       };
66805     } catch (...) {
66806       {
66807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66808       };
66809     }
66810   }
66811 }
66812
66813
66814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
66815   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66816   Dali::Toolkit::ControlOrientation::Type arg2 ;
66817
66818   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66819   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
66820   {
66821     try {
66822       (arg1)->SetOrientation(arg2);
66823     } catch (std::out_of_range& e) {
66824       {
66825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66826       };
66827     } catch (std::exception& e) {
66828       {
66829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66830       };
66831     } catch (...) {
66832       {
66833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66834       };
66835     }
66836   }
66837 }
66838
66839
66840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
66841   int jresult ;
66842   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66843   Dali::Toolkit::ControlOrientation::Type result;
66844
66845   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66846   {
66847     try {
66848       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
66849     } catch (std::out_of_range& e) {
66850       {
66851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66852       };
66853     } catch (std::exception& e) {
66854       {
66855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66856       };
66857     } catch (...) {
66858       {
66859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66860       };
66861     }
66862   }
66863   jresult = (int)result;
66864   return jresult;
66865 }
66866
66867
66868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
66869   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66870   Dali::Property::Map *arg2 = 0 ;
66871
66872   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66873   arg2 = (Dali::Property::Map *)jarg2;
66874   if (!arg2) {
66875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
66876     return ;
66877   }
66878   {
66879     try {
66880       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
66881     } catch (std::out_of_range& e) {
66882       {
66883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66884       };
66885     } catch (std::exception& e) {
66886       {
66887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (...) {
66890       {
66891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66892       };
66893     }
66894   }
66895 }
66896
66897
66898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
66899   void * jresult ;
66900   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66901   Dali::Property::Map result;
66902
66903   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66904   {
66905     try {
66906       result = (arg1)->GetLayoutProperties();
66907     } catch (std::out_of_range& e) {
66908       {
66909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66910       };
66911     } catch (std::exception& e) {
66912       {
66913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66914       };
66915     } catch (...) {
66916       {
66917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66918       };
66919     }
66920   }
66921   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
66922   return jresult;
66923 }
66924
66925
66926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
66927   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66928   unsigned int arg2 ;
66929   Dali::Vector3 *arg3 = 0 ;
66930   Dali::Vector3 *arg4 = 0 ;
66931
66932   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66933   arg2 = (unsigned int)jarg2;
66934   arg3 = (Dali::Vector3 *)jarg3;
66935   if (!arg3) {
66936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66937     return ;
66938   }
66939   arg4 = (Dali::Vector3 *)jarg4;
66940   if (!arg4) {
66941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66942     return ;
66943   }
66944   {
66945     try {
66946       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
66947     } catch (std::out_of_range& e) {
66948       {
66949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66950       };
66951     } catch (std::exception& e) {
66952       {
66953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66954       };
66955     } catch (...) {
66956       {
66957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66958       };
66959     }
66960   }
66961 }
66962
66963
66964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
66965   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66966   Dali::Vector3 *arg2 = 0 ;
66967
66968   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66969   arg2 = (Dali::Vector3 *)jarg2;
66970   if (!arg2) {
66971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66972     return ;
66973   }
66974   {
66975     try {
66976       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
66977     } catch (std::out_of_range& e) {
66978       {
66979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66980       };
66981     } catch (std::exception& e) {
66982       {
66983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66984       };
66985     } catch (...) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66988       };
66989     }
66990   }
66991 }
66992
66993
66994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
66995   float jresult ;
66996   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66997   unsigned int arg2 ;
66998   Dali::Vector3 arg3 ;
66999   Dali::Vector3 *argp3 ;
67000   float result;
67001
67002   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67003   arg2 = (unsigned int)jarg2;
67004   argp3 = (Dali::Vector3 *)jarg3;
67005   if (!argp3) {
67006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67007     return 0;
67008   }
67009   arg3 = *argp3;
67010   {
67011     try {
67012       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
67013     } catch (std::out_of_range& e) {
67014       {
67015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67016       };
67017     } catch (std::exception& e) {
67018       {
67019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67020       };
67021     } catch (...) {
67022       {
67023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67024       };
67025     }
67026   }
67027   jresult = result;
67028   return jresult;
67029 }
67030
67031
67032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
67033   float jresult ;
67034   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67035   float arg2 ;
67036   float result;
67037
67038   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67039   arg2 = (float)jarg2;
67040   {
67041     try {
67042       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
67043     } catch (std::out_of_range& e) {
67044       {
67045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67046       };
67047     } catch (std::exception& e) {
67048       {
67049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67050       };
67051     } catch (...) {
67052       {
67053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67054       };
67055     }
67056   }
67057   jresult = result;
67058   return jresult;
67059 }
67060
67061
67062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
67063   float jresult ;
67064   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67065   unsigned int arg2 ;
67066   float result;
67067
67068   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67069   arg2 = (unsigned int)jarg2;
67070   {
67071     try {
67072       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
67073     } catch (std::out_of_range& e) {
67074       {
67075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67076       };
67077     } catch (std::exception& e) {
67078       {
67079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67080       };
67081     } catch (...) {
67082       {
67083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67084       };
67085     }
67086   }
67087   jresult = result;
67088   return jresult;
67089 }
67090
67091
67092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
67093   void * jresult ;
67094   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67095   float arg2 ;
67096   Dali::Vector3 arg3 ;
67097   Dali::Vector3 *argp3 ;
67098   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
67099
67100   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67101   arg2 = (float)jarg2;
67102   argp3 = (Dali::Vector3 *)jarg3;
67103   if (!argp3) {
67104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67105     return 0;
67106   }
67107   arg3 = *argp3;
67108   {
67109     try {
67110       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
67111     } catch (std::out_of_range& e) {
67112       {
67113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67114       };
67115     } catch (std::exception& e) {
67116       {
67117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67118       };
67119     } catch (...) {
67120       {
67121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67122       };
67123     }
67124   }
67125   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
67126   return jresult;
67127 }
67128
67129
67130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
67131   float jresult ;
67132   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67133   int arg2 ;
67134   float arg3 ;
67135   Dali::Vector3 *arg4 = 0 ;
67136   float result;
67137
67138   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67139   arg2 = (int)jarg2;
67140   arg3 = (float)jarg3;
67141   arg4 = (Dali::Vector3 *)jarg4;
67142   if (!arg4) {
67143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67144     return 0;
67145   }
67146   {
67147     try {
67148       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
67149     } catch (std::out_of_range& e) {
67150       {
67151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67152       };
67153     } catch (std::exception& e) {
67154       {
67155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67156       };
67157     } catch (...) {
67158       {
67159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67160       };
67161     }
67162   }
67163   jresult = result;
67164   return jresult;
67165 }
67166
67167
67168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
67169   unsigned int jresult ;
67170   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67171   Dali::Vector3 arg2 ;
67172   Dali::Vector3 *argp2 ;
67173   unsigned int result;
67174
67175   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67176   argp2 = (Dali::Vector3 *)jarg2;
67177   if (!argp2) {
67178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67179     return 0;
67180   }
67181   arg2 = *argp2;
67182   {
67183     try {
67184       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
67185     } catch (std::out_of_range& e) {
67186       {
67187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67188       };
67189     } catch (std::exception& e) {
67190       {
67191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67192       };
67193     } catch (...) {
67194       {
67195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67196       };
67197     }
67198   }
67199   jresult = result;
67200   return jresult;
67201 }
67202
67203
67204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
67205   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67206   unsigned int arg2 ;
67207   Dali::Vector3 *arg3 = 0 ;
67208   Dali::Vector3 *arg4 = 0 ;
67209
67210   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67211   arg2 = (unsigned int)jarg2;
67212   arg3 = (Dali::Vector3 *)jarg3;
67213   if (!arg3) {
67214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67215     return ;
67216   }
67217   arg4 = (Dali::Vector3 *)jarg4;
67218   if (!arg4) {
67219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67220     return ;
67221   }
67222   {
67223     try {
67224       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
67225     } catch (std::out_of_range& e) {
67226       {
67227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67228       };
67229     } catch (std::exception& e) {
67230       {
67231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67232       };
67233     } catch (...) {
67234       {
67235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67236       };
67237     }
67238   }
67239 }
67240
67241
67242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
67243   void * jresult ;
67244   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67245   Dali::Degree result;
67246
67247   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67248   {
67249     try {
67250       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
67251     } catch (std::out_of_range& e) {
67252       {
67253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67254       };
67255     } catch (std::exception& e) {
67256       {
67257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67258       };
67259     } catch (...) {
67260       {
67261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67262       };
67263     }
67264   }
67265   jresult = new Dali::Degree((const Dali::Degree &)result);
67266   return jresult;
67267 }
67268
67269
67270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
67271   float jresult ;
67272   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67273   float result;
67274
67275   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67276   {
67277     try {
67278       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
67279     } catch (std::out_of_range& e) {
67280       {
67281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67282       };
67283     } catch (std::exception& e) {
67284       {
67285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67286       };
67287     } catch (...) {
67288       {
67289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67290       };
67291     }
67292   }
67293   jresult = result;
67294   return jresult;
67295 }
67296
67297
67298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
67299   float jresult ;
67300   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67301   float result;
67302
67303   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67304   {
67305     try {
67306       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
67307     } catch (std::out_of_range& e) {
67308       {
67309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67310       };
67311     } catch (std::exception& e) {
67312       {
67313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67314       };
67315     } catch (...) {
67316       {
67317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67318       };
67319     }
67320   }
67321   jresult = result;
67322   return jresult;
67323 }
67324
67325
67326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
67327   float jresult ;
67328   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67329   float result;
67330
67331   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67332   {
67333     try {
67334       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
67335     } catch (std::out_of_range& e) {
67336       {
67337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67338       };
67339     } catch (std::exception& e) {
67340       {
67341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67342       };
67343     } catch (...) {
67344       {
67345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67346       };
67347     }
67348   }
67349   jresult = result;
67350   return jresult;
67351 }
67352
67353
67354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
67355   int jresult ;
67356   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67357   int arg2 ;
67358   int arg3 ;
67359   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
67360   bool arg5 ;
67361   int result;
67362
67363   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67364   arg2 = (int)jarg2;
67365   arg3 = (int)jarg3;
67366   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
67367   arg5 = jarg5 ? true : false;
67368   {
67369     try {
67370       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
67371     } catch (std::out_of_range& e) {
67372       {
67373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67374       };
67375     } catch (std::exception& e) {
67376       {
67377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67378       };
67379     } catch (...) {
67380       {
67381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67382       };
67383     }
67384   }
67385   jresult = result;
67386   return jresult;
67387 }
67388
67389
67390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
67391   float jresult ;
67392   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67393   float result;
67394
67395   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67396   {
67397     try {
67398       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
67399     } catch (std::out_of_range& e) {
67400       {
67401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67402       };
67403     } catch (std::exception& e) {
67404       {
67405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67406       };
67407     } catch (...) {
67408       {
67409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67410       };
67411     }
67412   }
67413   jresult = result;
67414   return jresult;
67415 }
67416
67417
67418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
67419   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67420   Dali::Actor *arg2 = 0 ;
67421   int arg3 ;
67422   Dali::Vector3 *arg4 = 0 ;
67423   Dali::Actor *arg5 = 0 ;
67424
67425   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67426   arg2 = (Dali::Actor *)jarg2;
67427   if (!arg2) {
67428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
67429     return ;
67430   }
67431   arg3 = (int)jarg3;
67432   arg4 = (Dali::Vector3 *)jarg4;
67433   if (!arg4) {
67434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67435     return ;
67436   }
67437   arg5 = (Dali::Actor *)jarg5;
67438   if (!arg5) {
67439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
67440     return ;
67441   }
67442   {
67443     try {
67444       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
67445     } catch (std::out_of_range& e) {
67446       {
67447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67448       };
67449     } catch (std::exception& e) {
67450       {
67451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67452       };
67453     } catch (...) {
67454       {
67455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67456       };
67457     }
67458   }
67459 }
67460
67461
67462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
67463   void * jresult ;
67464   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67465   int arg2 ;
67466   float arg3 ;
67467   Dali::Vector3 *arg4 = 0 ;
67468   Dali::Vector3 result;
67469
67470   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67471   arg2 = (int)jarg2;
67472   arg3 = (float)jarg3;
67473   arg4 = (Dali::Vector3 *)jarg4;
67474   if (!arg4) {
67475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67476     return 0;
67477   }
67478   {
67479     try {
67480       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
67481     } catch (std::out_of_range& e) {
67482       {
67483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67484       };
67485     } catch (std::exception& e) {
67486       {
67487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67488       };
67489     } catch (...) {
67490       {
67491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67492       };
67493     }
67494   }
67495   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
67496   return jresult;
67497 }
67498
67499
67500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
67501   void * jresult ;
67502   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
67503   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
67504
67505   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
67506   {
67507     try {
67508       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
67509     } catch (std::out_of_range& e) {
67510       {
67511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67512       };
67513     } catch (std::exception& e) {
67514       {
67515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67516       };
67517     } catch (...) {
67518       {
67519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67520       };
67521     }
67522   }
67523   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
67524   return jresult;
67525 }
67526
67527
67528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
67529   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67530
67531   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67532   {
67533     try {
67534       delete arg1;
67535     } catch (std::out_of_range& e) {
67536       {
67537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67538       };
67539     } catch (std::exception& e) {
67540       {
67541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67542       };
67543     } catch (...) {
67544       {
67545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67546       };
67547     }
67548   }
67549 }
67550
67551
67552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
67553   unsigned int jresult ;
67554   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67555   unsigned int result;
67556
67557   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67558   {
67559     try {
67560       result = (unsigned int)(arg1)->GetNumberOfItems();
67561     } catch (std::out_of_range& e) {
67562       {
67563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67564       };
67565     } catch (std::exception& e) {
67566       {
67567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67568       };
67569     } catch (...) {
67570       {
67571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67572       };
67573     }
67574   }
67575   jresult = result;
67576   return jresult;
67577 }
67578
67579
67580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
67581   void * jresult ;
67582   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67583   unsigned int arg2 ;
67584   Dali::Actor result;
67585
67586   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67587   arg2 = (unsigned int)jarg2;
67588   {
67589     try {
67590       result = (arg1)->NewItem(arg2);
67591     } catch (std::out_of_range& e) {
67592       {
67593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67594       };
67595     } catch (std::exception& e) {
67596       {
67597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67598       };
67599     } catch (...) {
67600       {
67601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67602       };
67603     }
67604   }
67605   jresult = new Dali::Actor((const Dali::Actor &)result);
67606   return jresult;
67607 }
67608
67609
67610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
67611   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67612   unsigned int arg2 ;
67613   Dali::Actor arg3 ;
67614   Dali::Actor *argp3 ;
67615
67616   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67617   arg2 = (unsigned int)jarg2;
67618   argp3 = (Dali::Actor *)jarg3;
67619   if (!argp3) {
67620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67621     return ;
67622   }
67623   arg3 = *argp3;
67624   {
67625     try {
67626       (arg1)->ItemReleased(arg2,arg3);
67627     } catch (std::out_of_range& e) {
67628       {
67629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67630       };
67631     } catch (std::exception& e) {
67632       {
67633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67634       };
67635     } catch (...) {
67636       {
67637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67638       };
67639     }
67640   }
67641 }
67642
67643
67644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
67645   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67646   unsigned int arg2 ;
67647   Dali::Actor arg3 ;
67648   Dali::Actor *argp3 ;
67649
67650   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67651   arg2 = (unsigned int)jarg2;
67652   argp3 = (Dali::Actor *)jarg3;
67653   if (!argp3) {
67654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67655     return ;
67656   }
67657   arg3 = *argp3;
67658   {
67659     try {
67660       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
67661     } catch (std::out_of_range& e) {
67662       {
67663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67664       };
67665     } catch (std::exception& e) {
67666       {
67667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67668       };
67669     } catch (...) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67672       };
67673     }
67674   }
67675 }
67676
67677
67678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
67679   void * jresult ;
67680   Dali::Toolkit::ItemFactory *result = 0 ;
67681
67682   {
67683     try {
67684       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
67685     } catch (std::out_of_range& e) {
67686       {
67687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67688       };
67689     } catch (std::exception& e) {
67690       {
67691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67692       };
67693     } catch (...) {
67694       {
67695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67696       };
67697     }
67698   }
67699   jresult = (void *)result;
67700   return jresult;
67701 }
67702
67703
67704 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) {
67705   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
67706   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
67707   if (director) {
67708     director->swig_connect_director(callback0, callback1, callback2);
67709   }
67710 }
67711
67712
67713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
67714   int jresult ;
67715   int result;
67716
67717   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
67718   jresult = (int)result;
67719   return jresult;
67720 }
67721
67722
67723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
67724   int jresult ;
67725   int result;
67726
67727   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
67728   jresult = (int)result;
67729   return jresult;
67730 }
67731
67732
67733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
67734   int jresult ;
67735   int result;
67736
67737   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
67738   jresult = (int)result;
67739   return jresult;
67740 }
67741
67742
67743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
67744   int jresult ;
67745   int result;
67746
67747   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
67748   jresult = (int)result;
67749   return jresult;
67750 }
67751
67752
67753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
67754   int jresult ;
67755   int result;
67756
67757   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
67758   jresult = (int)result;
67759   return jresult;
67760 }
67761
67762
67763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
67764   int jresult ;
67765   int result;
67766
67767   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
67768   jresult = (int)result;
67769   return jresult;
67770 }
67771
67772
67773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
67774   int jresult ;
67775   int result;
67776
67777   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
67778   jresult = (int)result;
67779   return jresult;
67780 }
67781
67782
67783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
67784   int jresult ;
67785   int result;
67786
67787   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
67788   jresult = (int)result;
67789   return jresult;
67790 }
67791
67792
67793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
67794   int jresult ;
67795   int result;
67796
67797   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
67798   jresult = (int)result;
67799   return jresult;
67800 }
67801
67802
67803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
67804   int jresult ;
67805   int result;
67806
67807   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
67808   jresult = (int)result;
67809   return jresult;
67810 }
67811
67812
67813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
67814   int jresult ;
67815   int result;
67816
67817   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
67818   jresult = (int)result;
67819   return jresult;
67820 }
67821
67822
67823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
67824   void * jresult ;
67825   Dali::Toolkit::ItemView::Property *result = 0 ;
67826
67827   {
67828     try {
67829       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
67830     } catch (std::out_of_range& e) {
67831       {
67832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67833       };
67834     } catch (std::exception& e) {
67835       {
67836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (...) {
67839       {
67840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67841       };
67842     }
67843   }
67844   jresult = (void *)result;
67845   return jresult;
67846 }
67847
67848
67849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
67850   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
67851
67852   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
67853   {
67854     try {
67855       delete arg1;
67856     } catch (std::out_of_range& e) {
67857       {
67858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67859       };
67860     } catch (std::exception& e) {
67861       {
67862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67863       };
67864     } catch (...) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67867       };
67868     }
67869   }
67870 }
67871
67872
67873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
67874   void * jresult ;
67875   Dali::Toolkit::ItemView *result = 0 ;
67876
67877   {
67878     try {
67879       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
67880     } catch (std::out_of_range& e) {
67881       {
67882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67883       };
67884     } catch (std::exception& e) {
67885       {
67886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67887       };
67888     } catch (...) {
67889       {
67890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67891       };
67892     }
67893   }
67894   jresult = (void *)result;
67895   return jresult;
67896 }
67897
67898
67899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
67900   void * jresult ;
67901   Dali::Toolkit::ItemView *arg1 = 0 ;
67902   Dali::Toolkit::ItemView *result = 0 ;
67903
67904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67905   if (!arg1) {
67906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
67907     return 0;
67908   }
67909   {
67910     try {
67911       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
67912     } catch (std::out_of_range& e) {
67913       {
67914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67915       };
67916     } catch (std::exception& e) {
67917       {
67918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67919       };
67920     } catch (...) {
67921       {
67922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67923       };
67924     }
67925   }
67926   jresult = (void *)result;
67927   return jresult;
67928 }
67929
67930
67931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
67932   void * jresult ;
67933   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67934   Dali::Toolkit::ItemView *arg2 = 0 ;
67935   Dali::Toolkit::ItemView *result = 0 ;
67936
67937   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67938   arg2 = (Dali::Toolkit::ItemView *)jarg2;
67939   if (!arg2) {
67940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
67941     return 0;
67942   }
67943   {
67944     try {
67945       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
67946     } catch (std::out_of_range& e) {
67947       {
67948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67949       };
67950     } catch (std::exception& e) {
67951       {
67952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67953       };
67954     } catch (...) {
67955       {
67956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67957       };
67958     }
67959   }
67960   jresult = (void *)result;
67961   return jresult;
67962 }
67963
67964
67965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
67966   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67967
67968   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67969   {
67970     try {
67971       delete arg1;
67972     } catch (std::out_of_range& e) {
67973       {
67974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67975       };
67976     } catch (std::exception& e) {
67977       {
67978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67979       };
67980     } catch (...) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67983       };
67984     }
67985   }
67986 }
67987
67988
67989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
67990   void * jresult ;
67991   Dali::Toolkit::ItemFactory *arg1 = 0 ;
67992   Dali::Toolkit::ItemView result;
67993
67994   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67995   if (!arg1) {
67996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
67997     return 0;
67998   }
67999   {
68000     try {
68001       result = Dali::Toolkit::ItemView::New(*arg1);
68002     } catch (std::out_of_range& e) {
68003       {
68004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68005       };
68006     } catch (std::exception& e) {
68007       {
68008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68009       };
68010     } catch (...) {
68011       {
68012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68013       };
68014     }
68015   }
68016   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
68017   return jresult;
68018 }
68019
68020
68021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
68022   void * jresult ;
68023   Dali::BaseHandle arg1 ;
68024   Dali::BaseHandle *argp1 ;
68025   Dali::Toolkit::ItemView result;
68026
68027   argp1 = (Dali::BaseHandle *)jarg1;
68028   if (!argp1) {
68029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68030     return 0;
68031   }
68032   arg1 = *argp1;
68033   {
68034     try {
68035       result = Dali::Toolkit::ItemView::DownCast(arg1);
68036     } catch (std::out_of_range& e) {
68037       {
68038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68039       };
68040     } catch (std::exception& e) {
68041       {
68042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68043       };
68044     } catch (...) {
68045       {
68046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68047       };
68048     }
68049   }
68050   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
68051   return jresult;
68052 }
68053
68054
68055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
68056   unsigned int jresult ;
68057   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68058   unsigned int result;
68059
68060   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68061   {
68062     try {
68063       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
68064     } catch (std::out_of_range& e) {
68065       {
68066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68067       };
68068     } catch (std::exception& e) {
68069       {
68070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68071       };
68072     } catch (...) {
68073       {
68074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68075       };
68076     }
68077   }
68078   jresult = result;
68079   return jresult;
68080 }
68081
68082
68083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
68084   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68085   Dali::Toolkit::ItemLayout *arg2 = 0 ;
68086
68087   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68088   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
68089   if (!arg2) {
68090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
68091     return ;
68092   }
68093   {
68094     try {
68095       (arg1)->AddLayout(*arg2);
68096     } catch (std::out_of_range& e) {
68097       {
68098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68099       };
68100     } catch (std::exception& e) {
68101       {
68102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68103       };
68104     } catch (...) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68107       };
68108     }
68109   }
68110 }
68111
68112
68113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
68114   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68115   unsigned int arg2 ;
68116
68117   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68118   arg2 = (unsigned int)jarg2;
68119   {
68120     try {
68121       (arg1)->RemoveLayout(arg2);
68122     } catch (std::out_of_range& e) {
68123       {
68124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68125       };
68126     } catch (std::exception& e) {
68127       {
68128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68133       };
68134     }
68135   }
68136 }
68137
68138
68139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
68140   void * jresult ;
68141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68142   unsigned int arg2 ;
68143   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68144
68145   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68146   arg2 = (unsigned int)jarg2;
68147   {
68148     try {
68149       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
68150     } catch (std::out_of_range& e) {
68151       {
68152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68153       };
68154     } catch (std::exception& e) {
68155       {
68156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68157       };
68158     } catch (...) {
68159       {
68160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68161       };
68162     }
68163   }
68164   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68165   return jresult;
68166 }
68167
68168
68169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
68170   void * jresult ;
68171   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68172   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68173
68174   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68175   {
68176     try {
68177       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
68178     } catch (std::out_of_range& e) {
68179       {
68180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68181       };
68182     } catch (std::exception& e) {
68183       {
68184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68185       };
68186     } catch (...) {
68187       {
68188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68189       };
68190     }
68191   }
68192   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68193   return jresult;
68194 }
68195
68196
68197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
68198   float jresult ;
68199   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68200   Dali::Toolkit::ItemId arg2 ;
68201   float result;
68202
68203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68204   arg2 = (Dali::Toolkit::ItemId)jarg2;
68205   {
68206     try {
68207       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
68208     } catch (std::out_of_range& e) {
68209       {
68210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68211       };
68212     } catch (std::exception& e) {
68213       {
68214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68215       };
68216     } catch (...) {
68217       {
68218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68219       };
68220     }
68221   }
68222   jresult = result;
68223   return jresult;
68224 }
68225
68226
68227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
68228   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68229   unsigned int arg2 ;
68230   Dali::Vector3 arg3 ;
68231   float arg4 ;
68232   Dali::Vector3 *argp3 ;
68233
68234   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68235   arg2 = (unsigned int)jarg2;
68236   argp3 = (Dali::Vector3 *)jarg3;
68237   if (!argp3) {
68238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68239     return ;
68240   }
68241   arg3 = *argp3;
68242   arg4 = (float)jarg4;
68243   {
68244     try {
68245       (arg1)->ActivateLayout(arg2,arg3,arg4);
68246     } catch (std::out_of_range& e) {
68247       {
68248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68249       };
68250     } catch (std::exception& e) {
68251       {
68252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68253       };
68254     } catch (...) {
68255       {
68256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68257       };
68258     }
68259   }
68260 }
68261
68262
68263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
68264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68265
68266   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68267   {
68268     try {
68269       (arg1)->DeactivateCurrentLayout();
68270     } catch (std::out_of_range& e) {
68271       {
68272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68273       };
68274     } catch (std::exception& e) {
68275       {
68276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68277       };
68278     } catch (...) {
68279       {
68280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68281       };
68282     }
68283   }
68284 }
68285
68286
68287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
68288   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68289   float arg2 ;
68290
68291   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68292   arg2 = (float)jarg2;
68293   {
68294     try {
68295       (arg1)->SetMinimumSwipeSpeed(arg2);
68296     } catch (std::out_of_range& e) {
68297       {
68298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68299       };
68300     } catch (std::exception& e) {
68301       {
68302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68303       };
68304     } catch (...) {
68305       {
68306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68307       };
68308     }
68309   }
68310 }
68311
68312
68313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
68314   float jresult ;
68315   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68316   float result;
68317
68318   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68319   {
68320     try {
68321       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
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 = result;
68337   return jresult;
68338 }
68339
68340
68341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
68342   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68343   float arg2 ;
68344
68345   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68346   arg2 = (float)jarg2;
68347   {
68348     try {
68349       (arg1)->SetMinimumSwipeDistance(arg2);
68350     } catch (std::out_of_range& e) {
68351       {
68352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68353       };
68354     } catch (std::exception& e) {
68355       {
68356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68361       };
68362     }
68363   }
68364 }
68365
68366
68367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
68368   float jresult ;
68369   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68370   float result;
68371
68372   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68373   {
68374     try {
68375       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
68376     } catch (std::out_of_range& e) {
68377       {
68378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68379       };
68380     } catch (std::exception& e) {
68381       {
68382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68383       };
68384     } catch (...) {
68385       {
68386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68387       };
68388     }
68389   }
68390   jresult = result;
68391   return jresult;
68392 }
68393
68394
68395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
68396   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68397   float arg2 ;
68398
68399   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68400   arg2 = (float)jarg2;
68401   {
68402     try {
68403       (arg1)->SetWheelScrollDistanceStep(arg2);
68404     } catch (std::out_of_range& e) {
68405       {
68406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68407       };
68408     } catch (std::exception& e) {
68409       {
68410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68411       };
68412     } catch (...) {
68413       {
68414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68415       };
68416     }
68417   }
68418 }
68419
68420
68421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
68422   float jresult ;
68423   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68424   float result;
68425
68426   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68427   {
68428     try {
68429       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
68430     } catch (std::out_of_range& e) {
68431       {
68432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68433       };
68434     } catch (std::exception& e) {
68435       {
68436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68437       };
68438     } catch (...) {
68439       {
68440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68441       };
68442     }
68443   }
68444   jresult = result;
68445   return jresult;
68446 }
68447
68448
68449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
68450   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68451   bool arg2 ;
68452
68453   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68454   arg2 = jarg2 ? true : false;
68455   {
68456     try {
68457       (arg1)->SetAnchoring(arg2);
68458     } catch (std::out_of_range& e) {
68459       {
68460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68461       };
68462     } catch (std::exception& e) {
68463       {
68464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68465       };
68466     } catch (...) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68469       };
68470     }
68471   }
68472 }
68473
68474
68475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
68476   unsigned int jresult ;
68477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68478   bool result;
68479
68480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68481   {
68482     try {
68483       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
68484     } catch (std::out_of_range& e) {
68485       {
68486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68487       };
68488     } catch (std::exception& e) {
68489       {
68490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68491       };
68492     } catch (...) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68495       };
68496     }
68497   }
68498   jresult = result;
68499   return jresult;
68500 }
68501
68502
68503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
68504   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68505   float arg2 ;
68506
68507   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68508   arg2 = (float)jarg2;
68509   {
68510     try {
68511       (arg1)->SetAnchoringDuration(arg2);
68512     } catch (std::out_of_range& e) {
68513       {
68514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68515       };
68516     } catch (std::exception& e) {
68517       {
68518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68519       };
68520     } catch (...) {
68521       {
68522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68523       };
68524     }
68525   }
68526 }
68527
68528
68529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
68530   float jresult ;
68531   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68532   float result;
68533
68534   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68535   {
68536     try {
68537       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
68538     } catch (std::out_of_range& e) {
68539       {
68540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68541       };
68542     } catch (std::exception& e) {
68543       {
68544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68545       };
68546     } catch (...) {
68547       {
68548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68549       };
68550     }
68551   }
68552   jresult = result;
68553   return jresult;
68554 }
68555
68556
68557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
68558   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68559   Dali::Toolkit::ItemId arg2 ;
68560   float arg3 ;
68561
68562   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68563   arg2 = (Dali::Toolkit::ItemId)jarg2;
68564   arg3 = (float)jarg3;
68565   {
68566     try {
68567       (arg1)->ScrollToItem(arg2,arg3);
68568     } catch (std::out_of_range& e) {
68569       {
68570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68571       };
68572     } catch (std::exception& e) {
68573       {
68574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68575       };
68576     } catch (...) {
68577       {
68578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68579       };
68580     }
68581   }
68582 }
68583
68584
68585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
68586   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68587   float arg2 ;
68588
68589   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68590   arg2 = (float)jarg2;
68591   {
68592     try {
68593       (arg1)->SetRefreshInterval(arg2);
68594     } catch (std::out_of_range& e) {
68595       {
68596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68597       };
68598     } catch (std::exception& e) {
68599       {
68600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68601       };
68602     } catch (...) {
68603       {
68604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68605       };
68606     }
68607   }
68608 }
68609
68610
68611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
68612   float jresult ;
68613   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68614   float result;
68615
68616   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68617   {
68618     try {
68619       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
68620     } catch (std::out_of_range& e) {
68621       {
68622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68623       };
68624     } catch (std::exception& e) {
68625       {
68626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68627       };
68628     } catch (...) {
68629       {
68630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68631       };
68632     }
68633   }
68634   jresult = result;
68635   return jresult;
68636 }
68637
68638
68639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
68640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68641
68642   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68643   {
68644     try {
68645       (arg1)->Refresh();
68646     } catch (std::out_of_range& e) {
68647       {
68648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68649       };
68650     } catch (std::exception& e) {
68651       {
68652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68653       };
68654     } catch (...) {
68655       {
68656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68657       };
68658     }
68659   }
68660 }
68661
68662
68663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
68664   void * jresult ;
68665   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68666   Dali::Toolkit::ItemId arg2 ;
68667   Dali::Actor result;
68668
68669   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68670   arg2 = (Dali::Toolkit::ItemId)jarg2;
68671   {
68672     try {
68673       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
68674     } catch (std::out_of_range& e) {
68675       {
68676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68677       };
68678     } catch (std::exception& e) {
68679       {
68680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68681       };
68682     } catch (...) {
68683       {
68684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68685       };
68686     }
68687   }
68688   jresult = new Dali::Actor((const Dali::Actor &)result);
68689   return jresult;
68690 }
68691
68692
68693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
68694   unsigned int jresult ;
68695   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68696   Dali::Actor arg2 ;
68697   Dali::Actor *argp2 ;
68698   Dali::Toolkit::ItemId result;
68699
68700   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68701   argp2 = (Dali::Actor *)jarg2;
68702   if (!argp2) {
68703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68704     return 0;
68705   }
68706   arg2 = *argp2;
68707   {
68708     try {
68709       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
68710     } catch (std::out_of_range& e) {
68711       {
68712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68713       };
68714     } catch (std::exception& e) {
68715       {
68716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68717       };
68718     } catch (...) {
68719       {
68720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68721       };
68722     }
68723   }
68724   jresult = result;
68725   return jresult;
68726 }
68727
68728
68729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
68730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68731   Dali::Toolkit::Item arg2 ;
68732   float arg3 ;
68733   Dali::Toolkit::Item *argp2 ;
68734
68735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68736   argp2 = (Dali::Toolkit::Item *)jarg2;
68737   if (!argp2) {
68738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
68739     return ;
68740   }
68741   arg2 = *argp2;
68742   arg3 = (float)jarg3;
68743   {
68744     try {
68745       (arg1)->InsertItem(arg2,arg3);
68746     } catch (std::out_of_range& e) {
68747       {
68748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68749       };
68750     } catch (std::exception& e) {
68751       {
68752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68753       };
68754     } catch (...) {
68755       {
68756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68757       };
68758     }
68759   }
68760 }
68761
68762
68763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
68764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68765   Dali::Toolkit::ItemContainer *arg2 = 0 ;
68766   float arg3 ;
68767
68768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68769   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
68770   if (!arg2) {
68771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
68772     return ;
68773   }
68774   arg3 = (float)jarg3;
68775   {
68776     try {
68777       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
68778     } catch (std::out_of_range& e) {
68779       {
68780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68781       };
68782     } catch (std::exception& e) {
68783       {
68784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68785       };
68786     } catch (...) {
68787       {
68788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68789       };
68790     }
68791   }
68792 }
68793
68794
68795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
68796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68797   Dali::Toolkit::ItemId arg2 ;
68798   float arg3 ;
68799
68800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68801   arg2 = (Dali::Toolkit::ItemId)jarg2;
68802   arg3 = (float)jarg3;
68803   {
68804     try {
68805       (arg1)->RemoveItem(arg2,arg3);
68806     } catch (std::out_of_range& e) {
68807       {
68808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68809       };
68810     } catch (std::exception& e) {
68811       {
68812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68813       };
68814     } catch (...) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68817       };
68818     }
68819   }
68820 }
68821
68822
68823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
68824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68825   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
68826   float arg3 ;
68827
68828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68829   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
68830   if (!arg2) {
68831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
68832     return ;
68833   }
68834   arg3 = (float)jarg3;
68835   {
68836     try {
68837       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
68838     } catch (std::out_of_range& e) {
68839       {
68840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68841       };
68842     } catch (std::exception& e) {
68843       {
68844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68845       };
68846     } catch (...) {
68847       {
68848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68849       };
68850     }
68851   }
68852 }
68853
68854
68855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
68856   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68857   Dali::Toolkit::Item arg2 ;
68858   float arg3 ;
68859   Dali::Toolkit::Item *argp2 ;
68860
68861   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68862   argp2 = (Dali::Toolkit::Item *)jarg2;
68863   if (!argp2) {
68864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
68865     return ;
68866   }
68867   arg2 = *argp2;
68868   arg3 = (float)jarg3;
68869   {
68870     try {
68871       (arg1)->ReplaceItem(arg2,arg3);
68872     } catch (std::out_of_range& e) {
68873       {
68874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68875       };
68876     } catch (std::exception& e) {
68877       {
68878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68879       };
68880     } catch (...) {
68881       {
68882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68883       };
68884     }
68885   }
68886 }
68887
68888
68889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
68890   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68891   Dali::Toolkit::ItemContainer *arg2 = 0 ;
68892   float arg3 ;
68893
68894   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68895   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
68896   if (!arg2) {
68897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
68898     return ;
68899   }
68900   arg3 = (float)jarg3;
68901   {
68902     try {
68903       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
68904     } catch (std::out_of_range& e) {
68905       {
68906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68907       };
68908     } catch (std::exception& e) {
68909       {
68910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68911       };
68912     } catch (...) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68915       };
68916     }
68917   }
68918 }
68919
68920
68921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
68922   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68923   Dali::Vector3 *arg2 = 0 ;
68924
68925   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68926   arg2 = (Dali::Vector3 *)jarg2;
68927   if (!arg2) {
68928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68929     return ;
68930   }
68931   {
68932     try {
68933       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
68934     } catch (std::out_of_range& e) {
68935       {
68936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68937       };
68938     } catch (std::exception& e) {
68939       {
68940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68941       };
68942     } catch (...) {
68943       {
68944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68945       };
68946     }
68947   }
68948 }
68949
68950
68951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
68952   void * jresult ;
68953   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68954   Dali::Vector3 result;
68955
68956   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68957   {
68958     try {
68959       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
68960     } catch (std::out_of_range& e) {
68961       {
68962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68963       };
68964     } catch (std::exception& e) {
68965       {
68966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68967       };
68968     } catch (...) {
68969       {
68970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68971       };
68972     }
68973   }
68974   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
68975   return jresult;
68976 }
68977
68978
68979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
68980   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68981   Dali::Vector3 *arg2 = 0 ;
68982
68983   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68984   arg2 = (Dali::Vector3 *)jarg2;
68985   if (!arg2) {
68986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68987     return ;
68988   }
68989   {
68990     try {
68991       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
68992     } catch (std::out_of_range& e) {
68993       {
68994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68995       };
68996     } catch (std::exception& e) {
68997       {
68998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68999       };
69000     } catch (...) {
69001       {
69002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69003       };
69004     }
69005   }
69006 }
69007
69008
69009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
69010   void * jresult ;
69011   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69012   Dali::Vector3 result;
69013
69014   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69015   {
69016     try {
69017       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
69018     } catch (std::out_of_range& e) {
69019       {
69020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69021       };
69022     } catch (std::exception& e) {
69023       {
69024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69025       };
69026     } catch (...) {
69027       {
69028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69029       };
69030     }
69031   }
69032   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
69038   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69039   Dali::Toolkit::ItemRange *arg2 = 0 ;
69040
69041   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69042   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69043   if (!arg2) {
69044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
69045     return ;
69046   }
69047   {
69048     try {
69049       (arg1)->GetItemsRange(*arg2);
69050     } catch (std::out_of_range& e) {
69051       {
69052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69053       };
69054     } catch (std::exception& e) {
69055       {
69056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69057       };
69058     } catch (...) {
69059       {
69060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69061       };
69062     }
69063   }
69064 }
69065
69066
69067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
69068   void * jresult ;
69069   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69070   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
69071
69072   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69073   {
69074     try {
69075       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
69076     } catch (std::out_of_range& e) {
69077       {
69078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69079       };
69080     } catch (std::exception& e) {
69081       {
69082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69083       };
69084     } catch (...) {
69085       {
69086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69087       };
69088     }
69089   }
69090   jresult = (void *)result;
69091   return jresult;
69092 }
69093
69094
69095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
69096   Dali::Vector3 *arg1 = 0 ;
69097   PropertyInputContainer *arg2 = 0 ;
69098
69099   arg1 = (Dali::Vector3 *)jarg1;
69100   if (!arg1) {
69101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69102     return ;
69103   }
69104   arg2 = (PropertyInputContainer *)jarg2;
69105   if (!arg2) {
69106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
69107     return ;
69108   }
69109   {
69110     try {
69111       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
69112     } catch (std::out_of_range& e) {
69113       {
69114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69115       };
69116     } catch (std::exception& e) {
69117       {
69118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69119       };
69120     } catch (...) {
69121       {
69122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69123       };
69124     }
69125   }
69126 }
69127
69128
69129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
69130   Dali::Vector3 *arg1 = 0 ;
69131   PropertyInputContainer *arg2 = 0 ;
69132
69133   arg1 = (Dali::Vector3 *)jarg1;
69134   if (!arg1) {
69135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69136     return ;
69137   }
69138   arg2 = (PropertyInputContainer *)jarg2;
69139   if (!arg2) {
69140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
69141     return ;
69142   }
69143   {
69144     try {
69145       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
69146     } catch (std::out_of_range& e) {
69147       {
69148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69149       };
69150     } catch (std::exception& e) {
69151       {
69152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69153       };
69154     } catch (...) {
69155       {
69156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69157       };
69158     }
69159   }
69160 }
69161
69162
69163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
69164   void * jresult ;
69165   Dali::Toolkit::ScrollViewEffect *result = 0 ;
69166
69167   {
69168     try {
69169       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
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 = (void *)result;
69185   return jresult;
69186 }
69187
69188
69189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
69190   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
69191
69192   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
69193   {
69194     try {
69195       delete arg1;
69196     } catch (std::out_of_range& e) {
69197       {
69198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69199       };
69200     } catch (std::exception& e) {
69201       {
69202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69203       };
69204     } catch (...) {
69205       {
69206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69207       };
69208     }
69209   }
69210 }
69211
69212
69213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
69214   void * jresult ;
69215   Dali::Path arg1 ;
69216   Dali::Vector3 *arg2 = 0 ;
69217   Dali::Property::Index arg3 ;
69218   Dali::Vector3 *arg4 = 0 ;
69219   unsigned int arg5 ;
69220   Dali::Path *argp1 ;
69221   Dali::Toolkit::ScrollViewPagePathEffect result;
69222
69223   argp1 = (Dali::Path *)jarg1;
69224   if (!argp1) {
69225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
69226     return 0;
69227   }
69228   arg1 = *argp1;
69229   arg2 = (Dali::Vector3 *)jarg2;
69230   if (!arg2) {
69231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69232     return 0;
69233   }
69234   arg3 = (Dali::Property::Index)jarg3;
69235   arg4 = (Dali::Vector3 *)jarg4;
69236   if (!arg4) {
69237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69238     return 0;
69239   }
69240   arg5 = (unsigned int)jarg5;
69241   {
69242     try {
69243       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
69244     } catch (std::out_of_range& e) {
69245       {
69246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (std::exception& e) {
69249       {
69250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69255       };
69256     }
69257   }
69258   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
69259   return jresult;
69260 }
69261
69262
69263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
69264   void * jresult ;
69265   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
69266
69267   {
69268     try {
69269       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
69270     } catch (std::out_of_range& e) {
69271       {
69272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69273       };
69274     } catch (std::exception& e) {
69275       {
69276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69277       };
69278     } catch (...) {
69279       {
69280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69281       };
69282     }
69283   }
69284   jresult = (void *)result;
69285   return jresult;
69286 }
69287
69288
69289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
69290   void * jresult ;
69291   Dali::BaseHandle arg1 ;
69292   Dali::BaseHandle *argp1 ;
69293   Dali::Toolkit::ScrollViewPagePathEffect result;
69294
69295   argp1 = (Dali::BaseHandle *)jarg1;
69296   if (!argp1) {
69297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69298     return 0;
69299   }
69300   arg1 = *argp1;
69301   {
69302     try {
69303       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
69304     } catch (std::out_of_range& e) {
69305       {
69306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (std::exception& e) {
69309       {
69310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (...) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69315       };
69316     }
69317   }
69318   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
69319   return jresult;
69320 }
69321
69322
69323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
69324   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
69325   Dali::Actor arg2 ;
69326   unsigned int arg3 ;
69327   Dali::Actor *argp2 ;
69328
69329   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
69330   argp2 = (Dali::Actor *)jarg2;
69331   if (!argp2) {
69332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69333     return ;
69334   }
69335   arg2 = *argp2;
69336   arg3 = (unsigned int)jarg3;
69337   {
69338     try {
69339       (arg1)->ApplyToPage(arg2,arg3);
69340     } catch (std::out_of_range& e) {
69341       {
69342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69343       };
69344     } catch (std::exception& e) {
69345       {
69346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69347       };
69348     } catch (...) {
69349       {
69350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69351       };
69352     }
69353   }
69354 }
69355
69356
69357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
69358   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
69359
69360   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
69361   {
69362     try {
69363       delete arg1;
69364     } catch (std::out_of_range& e) {
69365       {
69366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69367       };
69368     } catch (std::exception& e) {
69369       {
69370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69371       };
69372     } catch (...) {
69373       {
69374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69375       };
69376     }
69377   }
69378 }
69379
69380
69381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
69382   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69383   Dali::Toolkit::ClampState arg2 ;
69384
69385   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69386   arg2 = (Dali::Toolkit::ClampState)jarg2;
69387   if (arg1) (arg1)->x = arg2;
69388 }
69389
69390
69391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
69392   int jresult ;
69393   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69394   Dali::Toolkit::ClampState result;
69395
69396   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69397   result = (Dali::Toolkit::ClampState) ((arg1)->x);
69398   jresult = (int)result;
69399   return jresult;
69400 }
69401
69402
69403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
69404   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69405   Dali::Toolkit::ClampState arg2 ;
69406
69407   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69408   arg2 = (Dali::Toolkit::ClampState)jarg2;
69409   if (arg1) (arg1)->y = arg2;
69410 }
69411
69412
69413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
69414   int jresult ;
69415   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69416   Dali::Toolkit::ClampState result;
69417
69418   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69419   result = (Dali::Toolkit::ClampState) ((arg1)->y);
69420   jresult = (int)result;
69421   return jresult;
69422 }
69423
69424
69425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
69426   void * jresult ;
69427   Dali::Toolkit::ClampState2D *result = 0 ;
69428
69429   {
69430     try {
69431       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
69432     } catch (std::out_of_range& e) {
69433       {
69434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69435       };
69436     } catch (std::exception& e) {
69437       {
69438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69439       };
69440     } catch (...) {
69441       {
69442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69443       };
69444     }
69445   }
69446   jresult = (void *)result;
69447   return jresult;
69448 }
69449
69450
69451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
69452   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69453
69454   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69455   {
69456     try {
69457       delete arg1;
69458     } catch (std::out_of_range& e) {
69459       {
69460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69461       };
69462     } catch (std::exception& e) {
69463       {
69464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69465       };
69466     } catch (...) {
69467       {
69468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69469       };
69470     }
69471   }
69472 }
69473
69474
69475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
69476   void * jresult ;
69477   float arg1 ;
69478   float arg2 ;
69479   bool arg3 ;
69480   Dali::Toolkit::RulerDomain *result = 0 ;
69481
69482   arg1 = (float)jarg1;
69483   arg2 = (float)jarg2;
69484   arg3 = jarg3 ? true : false;
69485   {
69486     try {
69487       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
69488     } catch (std::out_of_range& e) {
69489       {
69490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69491       };
69492     } catch (std::exception& e) {
69493       {
69494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69495       };
69496     } catch (...) {
69497       {
69498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69499       };
69500     }
69501   }
69502   jresult = (void *)result;
69503   return jresult;
69504 }
69505
69506
69507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
69508   void * jresult ;
69509   float arg1 ;
69510   float arg2 ;
69511   Dali::Toolkit::RulerDomain *result = 0 ;
69512
69513   arg1 = (float)jarg1;
69514   arg2 = (float)jarg2;
69515   {
69516     try {
69517       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
69518     } catch (std::out_of_range& e) {
69519       {
69520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69521       };
69522     } catch (std::exception& e) {
69523       {
69524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69525       };
69526     } catch (...) {
69527       {
69528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69529       };
69530     }
69531   }
69532   jresult = (void *)result;
69533   return jresult;
69534 }
69535
69536
69537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
69538   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69539   float arg2 ;
69540
69541   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69542   arg2 = (float)jarg2;
69543   if (arg1) (arg1)->min = arg2;
69544 }
69545
69546
69547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
69548   float jresult ;
69549   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69550   float result;
69551
69552   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69553   result = (float) ((arg1)->min);
69554   jresult = result;
69555   return jresult;
69556 }
69557
69558
69559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
69560   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69561   float arg2 ;
69562
69563   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69564   arg2 = (float)jarg2;
69565   if (arg1) (arg1)->max = arg2;
69566 }
69567
69568
69569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
69570   float jresult ;
69571   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69572   float result;
69573
69574   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69575   result = (float) ((arg1)->max);
69576   jresult = result;
69577   return jresult;
69578 }
69579
69580
69581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
69582   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69583   bool arg2 ;
69584
69585   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69586   arg2 = jarg2 ? true : false;
69587   if (arg1) (arg1)->enabled = arg2;
69588 }
69589
69590
69591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
69592   unsigned int jresult ;
69593   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69594   bool result;
69595
69596   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69597   result = (bool) ((arg1)->enabled);
69598   jresult = result;
69599   return jresult;
69600 }
69601
69602
69603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
69604   float jresult ;
69605   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69606   float arg2 ;
69607   float arg3 ;
69608   float arg4 ;
69609   float result;
69610
69611   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69612   arg2 = (float)jarg2;
69613   arg3 = (float)jarg3;
69614   arg4 = (float)jarg4;
69615   {
69616     try {
69617       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
69618     } catch (std::out_of_range& e) {
69619       {
69620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69621       };
69622     } catch (std::exception& e) {
69623       {
69624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69625       };
69626     } catch (...) {
69627       {
69628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69629       };
69630     }
69631   }
69632   jresult = result;
69633   return jresult;
69634 }
69635
69636
69637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
69638   float jresult ;
69639   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69640   float arg2 ;
69641   float arg3 ;
69642   float result;
69643
69644   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69645   arg2 = (float)jarg2;
69646   arg3 = (float)jarg3;
69647   {
69648     try {
69649       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
69650     } catch (std::out_of_range& e) {
69651       {
69652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69653       };
69654     } catch (std::exception& e) {
69655       {
69656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69657       };
69658     } catch (...) {
69659       {
69660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69661       };
69662     }
69663   }
69664   jresult = result;
69665   return jresult;
69666 }
69667
69668
69669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
69670   float jresult ;
69671   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69672   float arg2 ;
69673   float result;
69674
69675   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69676   arg2 = (float)jarg2;
69677   {
69678     try {
69679       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
69680     } catch (std::out_of_range& e) {
69681       {
69682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69683       };
69684     } catch (std::exception& e) {
69685       {
69686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69687       };
69688     } catch (...) {
69689       {
69690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69691       };
69692     }
69693   }
69694   jresult = result;
69695   return jresult;
69696 }
69697
69698
69699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
69700   float jresult ;
69701   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69702   float arg2 ;
69703   float arg3 ;
69704   float arg4 ;
69705   Dali::Toolkit::ClampState *arg5 = 0 ;
69706   float result;
69707
69708   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69709   arg2 = (float)jarg2;
69710   arg3 = (float)jarg3;
69711   arg4 = (float)jarg4;
69712   arg5 = (Dali::Toolkit::ClampState *)jarg5;
69713   if (!arg5) {
69714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
69715     return 0;
69716   }
69717   {
69718     try {
69719       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
69720     } catch (std::out_of_range& e) {
69721       {
69722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69723       };
69724     } catch (std::exception& e) {
69725       {
69726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69727       };
69728     } catch (...) {
69729       {
69730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69731       };
69732     }
69733   }
69734   jresult = result;
69735   return jresult;
69736 }
69737
69738
69739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
69740   float jresult ;
69741   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69742   float result;
69743
69744   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69745   {
69746     try {
69747       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
69748     } catch (std::out_of_range& e) {
69749       {
69750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69751       };
69752     } catch (std::exception& e) {
69753       {
69754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69755       };
69756     } catch (...) {
69757       {
69758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69759       };
69760     }
69761   }
69762   jresult = result;
69763   return jresult;
69764 }
69765
69766
69767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
69768   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69769
69770   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69771   {
69772     try {
69773       delete arg1;
69774     } catch (std::out_of_range& e) {
69775       {
69776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69777       };
69778     } catch (std::exception& e) {
69779       {
69780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69781       };
69782     } catch (...) {
69783       {
69784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69785       };
69786     }
69787   }
69788 }
69789
69790
69791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
69792   float jresult ;
69793   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69794   float arg2 ;
69795   float arg3 ;
69796   float result;
69797
69798   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69799   arg2 = (float)jarg2;
69800   arg3 = (float)jarg3;
69801   {
69802     try {
69803       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
69804     } catch (std::out_of_range& e) {
69805       {
69806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (std::exception& e) {
69809       {
69810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (...) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69815       };
69816     }
69817   }
69818   jresult = result;
69819   return jresult;
69820 }
69821
69822
69823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
69824   float jresult ;
69825   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69826   float arg2 ;
69827   float result;
69828
69829   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69830   arg2 = (float)jarg2;
69831   {
69832     try {
69833       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
69834     } catch (std::out_of_range& e) {
69835       {
69836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69837       };
69838     } catch (std::exception& e) {
69839       {
69840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69841       };
69842     } catch (...) {
69843       {
69844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69845       };
69846     }
69847   }
69848   jresult = result;
69849   return jresult;
69850 }
69851
69852
69853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
69854   float jresult ;
69855   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69856   unsigned int arg2 ;
69857   unsigned int *arg3 = 0 ;
69858   bool arg4 ;
69859   float result;
69860
69861   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69862   arg2 = (unsigned int)jarg2;
69863   arg3 = (unsigned int *)jarg3;
69864   arg4 = jarg4 ? true : false;
69865   {
69866     try {
69867       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
69868     } catch (std::out_of_range& e) {
69869       {
69870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69871       };
69872     } catch (std::exception& e) {
69873       {
69874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69875       };
69876     } catch (...) {
69877       {
69878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69879       };
69880     }
69881   }
69882   jresult = result;
69883   return jresult;
69884 }
69885
69886
69887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
69888   unsigned int jresult ;
69889   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69890   float arg2 ;
69891   bool arg3 ;
69892   unsigned int result;
69893
69894   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69895   arg2 = (float)jarg2;
69896   arg3 = jarg3 ? true : false;
69897   {
69898     try {
69899       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
69900     } catch (std::out_of_range& e) {
69901       {
69902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69903       };
69904     } catch (std::exception& e) {
69905       {
69906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69907       };
69908     } catch (...) {
69909       {
69910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69911       };
69912     }
69913   }
69914   jresult = result;
69915   return jresult;
69916 }
69917
69918
69919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
69920   unsigned int jresult ;
69921   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69922   unsigned int result;
69923
69924   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69925   {
69926     try {
69927       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
69928     } catch (std::out_of_range& e) {
69929       {
69930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69931       };
69932     } catch (std::exception& e) {
69933       {
69934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69935       };
69936     } catch (...) {
69937       {
69938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69939       };
69940     }
69941   }
69942   jresult = result;
69943   return jresult;
69944 }
69945
69946
69947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
69948   int jresult ;
69949   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69950   Dali::Toolkit::Ruler::RulerType result;
69951
69952   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69953   {
69954     try {
69955       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
69956     } catch (std::out_of_range& e) {
69957       {
69958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69959       };
69960     } catch (std::exception& e) {
69961       {
69962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69963       };
69964     } catch (...) {
69965       {
69966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69967       };
69968     }
69969   }
69970   jresult = (int)result;
69971   return jresult;
69972 }
69973
69974
69975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
69976   unsigned int jresult ;
69977   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69978   bool result;
69979
69980   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69981   {
69982     try {
69983       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
69984     } catch (std::out_of_range& e) {
69985       {
69986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (std::exception& e) {
69989       {
69990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69991       };
69992     } catch (...) {
69993       {
69994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69995       };
69996     }
69997   }
69998   jresult = result;
69999   return jresult;
70000 }
70001
70002
70003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
70004   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70005
70006   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70007   {
70008     try {
70009       (arg1)->Enable();
70010     } catch (std::out_of_range& e) {
70011       {
70012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70013       };
70014     } catch (std::exception& e) {
70015       {
70016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70017       };
70018     } catch (...) {
70019       {
70020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70021       };
70022     }
70023   }
70024 }
70025
70026
70027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
70028   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70029
70030   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70031   {
70032     try {
70033       (arg1)->Disable();
70034     } catch (std::out_of_range& e) {
70035       {
70036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70037       };
70038     } catch (std::exception& e) {
70039       {
70040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70041       };
70042     } catch (...) {
70043       {
70044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70045       };
70046     }
70047   }
70048 }
70049
70050
70051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
70052   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70053   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
70054   Dali::Toolkit::RulerDomain *argp2 ;
70055
70056   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70057   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
70058   if (!argp2) {
70059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
70060     return ;
70061   }
70062   arg2 = *argp2;
70063   {
70064     try {
70065       (arg1)->SetDomain(arg2);
70066     } catch (std::out_of_range& e) {
70067       {
70068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70069       };
70070     } catch (std::exception& e) {
70071       {
70072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70073       };
70074     } catch (...) {
70075       {
70076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70077       };
70078     }
70079   }
70080 }
70081
70082
70083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
70084   void * jresult ;
70085   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70086   Dali::Toolkit::RulerDomain *result = 0 ;
70087
70088   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70089   {
70090     try {
70091       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
70092     } catch (std::out_of_range& e) {
70093       {
70094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70095       };
70096     } catch (std::exception& e) {
70097       {
70098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70099       };
70100     } catch (...) {
70101       {
70102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70103       };
70104     }
70105   }
70106   jresult = (void *)result;
70107   return jresult;
70108 }
70109
70110
70111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
70112   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70113
70114   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70115   {
70116     try {
70117       (arg1)->DisableDomain();
70118     } catch (std::out_of_range& e) {
70119       {
70120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70121       };
70122     } catch (std::exception& e) {
70123       {
70124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70125       };
70126     } catch (...) {
70127       {
70128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70129       };
70130     }
70131   }
70132 }
70133
70134
70135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
70136   float jresult ;
70137   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70138   float arg2 ;
70139   float arg3 ;
70140   float arg4 ;
70141   float result;
70142
70143   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70144   arg2 = (float)jarg2;
70145   arg3 = (float)jarg3;
70146   arg4 = (float)jarg4;
70147   {
70148     try {
70149       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
70150     } catch (std::out_of_range& e) {
70151       {
70152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70153       };
70154     } catch (std::exception& e) {
70155       {
70156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70157       };
70158     } catch (...) {
70159       {
70160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70161       };
70162     }
70163   }
70164   jresult = result;
70165   return jresult;
70166 }
70167
70168
70169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
70170   float jresult ;
70171   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70172   float arg2 ;
70173   float arg3 ;
70174   float result;
70175
70176   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70177   arg2 = (float)jarg2;
70178   arg3 = (float)jarg3;
70179   {
70180     try {
70181       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
70182     } catch (std::out_of_range& e) {
70183       {
70184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70185       };
70186     } catch (std::exception& e) {
70187       {
70188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70189       };
70190     } catch (...) {
70191       {
70192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70193       };
70194     }
70195   }
70196   jresult = result;
70197   return jresult;
70198 }
70199
70200
70201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
70202   float jresult ;
70203   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70204   float arg2 ;
70205   float result;
70206
70207   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70208   arg2 = (float)jarg2;
70209   {
70210     try {
70211       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
70212     } catch (std::out_of_range& e) {
70213       {
70214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70215       };
70216     } catch (std::exception& e) {
70217       {
70218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70219       };
70220     } catch (...) {
70221       {
70222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70223       };
70224     }
70225   }
70226   jresult = result;
70227   return jresult;
70228 }
70229
70230
70231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
70232   float jresult ;
70233   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70234   float arg2 ;
70235   float arg3 ;
70236   float arg4 ;
70237   Dali::Toolkit::ClampState *arg5 = 0 ;
70238   float result;
70239
70240   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70241   arg2 = (float)jarg2;
70242   arg3 = (float)jarg3;
70243   arg4 = (float)jarg4;
70244   arg5 = (Dali::Toolkit::ClampState *)jarg5;
70245   if (!arg5) {
70246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
70247     return 0;
70248   }
70249   {
70250     try {
70251       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
70252     } catch (std::out_of_range& e) {
70253       {
70254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70255       };
70256     } catch (std::exception& e) {
70257       {
70258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70259       };
70260     } catch (...) {
70261       {
70262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70263       };
70264     }
70265   }
70266   jresult = result;
70267   return jresult;
70268 }
70269
70270
70271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
70272   float jresult ;
70273   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70274   float arg2 ;
70275   float arg3 ;
70276   float arg4 ;
70277   float arg5 ;
70278   float result;
70279
70280   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70281   arg2 = (float)jarg2;
70282   arg3 = (float)jarg3;
70283   arg4 = (float)jarg4;
70284   arg5 = (float)jarg5;
70285   {
70286     try {
70287       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
70288     } catch (std::out_of_range& e) {
70289       {
70290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70291       };
70292     } catch (std::exception& e) {
70293       {
70294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70295       };
70296     } catch (...) {
70297       {
70298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70299       };
70300     }
70301   }
70302   jresult = result;
70303   return jresult;
70304 }
70305
70306
70307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
70308   float jresult ;
70309   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70310   float arg2 ;
70311   float arg3 ;
70312   float arg4 ;
70313   float result;
70314
70315   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70316   arg2 = (float)jarg2;
70317   arg3 = (float)jarg3;
70318   arg4 = (float)jarg4;
70319   {
70320     try {
70321       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
70322     } catch (std::out_of_range& e) {
70323       {
70324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70325       };
70326     } catch (std::exception& e) {
70327       {
70328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70329       };
70330     } catch (...) {
70331       {
70332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70333       };
70334     }
70335   }
70336   jresult = result;
70337   return jresult;
70338 }
70339
70340
70341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
70342   float jresult ;
70343   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70344   float arg2 ;
70345   float arg3 ;
70346   float result;
70347
70348   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70349   arg2 = (float)jarg2;
70350   arg3 = (float)jarg3;
70351   {
70352     try {
70353       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
70354     } catch (std::out_of_range& e) {
70355       {
70356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70357       };
70358     } catch (std::exception& e) {
70359       {
70360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70361       };
70362     } catch (...) {
70363       {
70364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70365       };
70366     }
70367   }
70368   jresult = result;
70369   return jresult;
70370 }
70371
70372
70373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
70374   float jresult ;
70375   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70376   float arg2 ;
70377   float result;
70378
70379   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70380   arg2 = (float)jarg2;
70381   {
70382     try {
70383       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
70384     } catch (std::out_of_range& e) {
70385       {
70386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70387       };
70388     } catch (std::exception& e) {
70389       {
70390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70391       };
70392     } catch (...) {
70393       {
70394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70395       };
70396     }
70397   }
70398   jresult = result;
70399   return jresult;
70400 }
70401
70402
70403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
70404   float jresult ;
70405   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70406   float arg2 ;
70407   float arg3 ;
70408   float arg4 ;
70409   float arg5 ;
70410   Dali::Toolkit::ClampState *arg6 = 0 ;
70411   float result;
70412
70413   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70414   arg2 = (float)jarg2;
70415   arg3 = (float)jarg3;
70416   arg4 = (float)jarg4;
70417   arg5 = (float)jarg5;
70418   arg6 = (Dali::Toolkit::ClampState *)jarg6;
70419   if (!arg6) {
70420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
70421     return 0;
70422   }
70423   {
70424     try {
70425       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70433       };
70434     } catch (...) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70437       };
70438     }
70439   }
70440   jresult = result;
70441   return jresult;
70442 }
70443
70444
70445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
70446   void * jresult ;
70447   Dali::Toolkit::DefaultRuler *result = 0 ;
70448
70449   {
70450     try {
70451       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
70452     } catch (std::out_of_range& e) {
70453       {
70454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70455       };
70456     } catch (std::exception& e) {
70457       {
70458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70459       };
70460     } catch (...) {
70461       {
70462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70463       };
70464     }
70465   }
70466   jresult = (void *)result;
70467   return jresult;
70468 }
70469
70470
70471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
70472   float jresult ;
70473   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70474   float arg2 ;
70475   float arg3 ;
70476   float result;
70477
70478   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70479   arg2 = (float)jarg2;
70480   arg3 = (float)jarg3;
70481   {
70482     try {
70483       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
70484     } catch (std::out_of_range& e) {
70485       {
70486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (std::exception& e) {
70489       {
70490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70491       };
70492     } catch (...) {
70493       {
70494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70495       };
70496     }
70497   }
70498   jresult = result;
70499   return jresult;
70500 }
70501
70502
70503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
70504   float jresult ;
70505   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70506   unsigned int arg2 ;
70507   unsigned int *arg3 = 0 ;
70508   bool arg4 ;
70509   float result;
70510
70511   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70512   arg2 = (unsigned int)jarg2;
70513   arg3 = (unsigned int *)jarg3;
70514   arg4 = jarg4 ? true : false;
70515   {
70516     try {
70517       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
70518     } catch (std::out_of_range& e) {
70519       {
70520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70521       };
70522     } catch (std::exception& e) {
70523       {
70524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70525       };
70526     } catch (...) {
70527       {
70528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70529       };
70530     }
70531   }
70532   jresult = result;
70533   return jresult;
70534 }
70535
70536
70537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
70538   unsigned int jresult ;
70539   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70540   float arg2 ;
70541   bool arg3 ;
70542   unsigned int result;
70543
70544   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70545   arg2 = (float)jarg2;
70546   arg3 = jarg3 ? true : false;
70547   {
70548     try {
70549       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
70550     } catch (std::out_of_range& e) {
70551       {
70552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (std::exception& e) {
70555       {
70556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70557       };
70558     } catch (...) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70561       };
70562     }
70563   }
70564   jresult = result;
70565   return jresult;
70566 }
70567
70568
70569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
70570   unsigned int jresult ;
70571   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70572   unsigned int result;
70573
70574   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70575   {
70576     try {
70577       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
70578     } catch (std::out_of_range& e) {
70579       {
70580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70581       };
70582     } catch (std::exception& e) {
70583       {
70584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70585       };
70586     } catch (...) {
70587       {
70588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70589       };
70590     }
70591   }
70592   jresult = result;
70593   return jresult;
70594 }
70595
70596
70597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
70598   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70599
70600   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70601   {
70602     try {
70603       delete arg1;
70604     } catch (std::out_of_range& e) {
70605       {
70606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70607       };
70608     } catch (std::exception& e) {
70609       {
70610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70611       };
70612     } catch (...) {
70613       {
70614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70615       };
70616     }
70617   }
70618 }
70619
70620
70621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
70622   void * jresult ;
70623   float arg1 ;
70624   Dali::Toolkit::FixedRuler *result = 0 ;
70625
70626   arg1 = (float)jarg1;
70627   {
70628     try {
70629       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
70630     } catch (std::out_of_range& e) {
70631       {
70632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70633       };
70634     } catch (std::exception& e) {
70635       {
70636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70637       };
70638     } catch (...) {
70639       {
70640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70641       };
70642     }
70643   }
70644   jresult = (void *)result;
70645   return jresult;
70646 }
70647
70648
70649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
70650   void * jresult ;
70651   Dali::Toolkit::FixedRuler *result = 0 ;
70652
70653   {
70654     try {
70655       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
70656     } catch (std::out_of_range& e) {
70657       {
70658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70659       };
70660     } catch (std::exception& e) {
70661       {
70662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70663       };
70664     } catch (...) {
70665       {
70666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70667       };
70668     }
70669   }
70670   jresult = (void *)result;
70671   return jresult;
70672 }
70673
70674
70675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
70676   float jresult ;
70677   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70678   float arg2 ;
70679   float arg3 ;
70680   float result;
70681
70682   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70683   arg2 = (float)jarg2;
70684   arg3 = (float)jarg3;
70685   {
70686     try {
70687       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
70688     } catch (std::out_of_range& e) {
70689       {
70690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70691       };
70692     } catch (std::exception& e) {
70693       {
70694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70695       };
70696     } catch (...) {
70697       {
70698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70699       };
70700     }
70701   }
70702   jresult = result;
70703   return jresult;
70704 }
70705
70706
70707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
70708   float jresult ;
70709   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70710   unsigned int arg2 ;
70711   unsigned int *arg3 = 0 ;
70712   bool arg4 ;
70713   float result;
70714
70715   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70716   arg2 = (unsigned int)jarg2;
70717   arg3 = (unsigned int *)jarg3;
70718   arg4 = jarg4 ? true : false;
70719   {
70720     try {
70721       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
70722     } catch (std::out_of_range& e) {
70723       {
70724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70725       };
70726     } catch (std::exception& e) {
70727       {
70728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70729       };
70730     } catch (...) {
70731       {
70732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70733       };
70734     }
70735   }
70736   jresult = result;
70737   return jresult;
70738 }
70739
70740
70741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
70742   unsigned int jresult ;
70743   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70744   float arg2 ;
70745   bool arg3 ;
70746   unsigned int result;
70747
70748   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70749   arg2 = (float)jarg2;
70750   arg3 = jarg3 ? true : false;
70751   {
70752     try {
70753       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
70754     } catch (std::out_of_range& e) {
70755       {
70756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70757       };
70758     } catch (std::exception& e) {
70759       {
70760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70761       };
70762     } catch (...) {
70763       {
70764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70765       };
70766     }
70767   }
70768   jresult = result;
70769   return jresult;
70770 }
70771
70772
70773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
70774   unsigned int jresult ;
70775   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70776   unsigned int result;
70777
70778   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70779   {
70780     try {
70781       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
70782     } catch (std::out_of_range& e) {
70783       {
70784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70785       };
70786     } catch (std::exception& e) {
70787       {
70788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70789       };
70790     } catch (...) {
70791       {
70792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70793       };
70794     }
70795   }
70796   jresult = result;
70797   return jresult;
70798 }
70799
70800
70801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
70802   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70803
70804   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70805   {
70806     try {
70807       delete arg1;
70808     } catch (std::out_of_range& e) {
70809       {
70810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70811       };
70812     } catch (std::exception& e) {
70813       {
70814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70815       };
70816     } catch (...) {
70817       {
70818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70819       };
70820     }
70821   }
70822 }
70823
70824
70825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
70826   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70827   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
70828
70829   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70830   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
70831   if (arg1) (arg1)->scale = *arg2;
70832 }
70833
70834
70835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
70836   void * jresult ;
70837   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70838   Dali::Toolkit::ClampState2D *result = 0 ;
70839
70840   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70841   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
70842   jresult = (void *)result;
70843   return jresult;
70844 }
70845
70846
70847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
70848   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70849   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
70850
70851   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70852   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
70853   if (arg1) (arg1)->position = *arg2;
70854 }
70855
70856
70857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
70858   void * jresult ;
70859   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70860   Dali::Toolkit::ClampState2D *result = 0 ;
70861
70862   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70863   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
70864   jresult = (void *)result;
70865   return jresult;
70866 }
70867
70868
70869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
70870   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70871   Dali::Toolkit::ClampState arg2 ;
70872
70873   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70874   arg2 = (Dali::Toolkit::ClampState)jarg2;
70875   if (arg1) (arg1)->rotation = arg2;
70876 }
70877
70878
70879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
70880   int jresult ;
70881   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70882   Dali::Toolkit::ClampState result;
70883
70884   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70885   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
70886   jresult = (int)result;
70887   return jresult;
70888 }
70889
70890
70891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
70892   void * jresult ;
70893   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
70894
70895   {
70896     try {
70897       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
70898     } catch (std::out_of_range& e) {
70899       {
70900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70901       };
70902     } catch (std::exception& e) {
70903       {
70904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70905       };
70906     } catch (...) {
70907       {
70908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70909       };
70910     }
70911   }
70912   jresult = (void *)result;
70913   return jresult;
70914 }
70915
70916
70917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
70918   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70919
70920   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70921   {
70922     try {
70923       delete arg1;
70924     } catch (std::out_of_range& e) {
70925       {
70926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70927       };
70928     } catch (std::exception& e) {
70929       {
70930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70931       };
70932     } catch (...) {
70933       {
70934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70935       };
70936     }
70937   }
70938 }
70939
70940
70941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
70942   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70943   Dali::Toolkit::SnapType arg2 ;
70944
70945   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70946   arg2 = (Dali::Toolkit::SnapType)jarg2;
70947   if (arg1) (arg1)->type = arg2;
70948 }
70949
70950
70951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
70952   int jresult ;
70953   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70954   Dali::Toolkit::SnapType result;
70955
70956   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70957   result = (Dali::Toolkit::SnapType) ((arg1)->type);
70958   jresult = (int)result;
70959   return jresult;
70960 }
70961
70962
70963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
70964   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70965   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
70966
70967   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70968   arg2 = (Dali::Vector2 *)jarg2;
70969   if (arg1) (arg1)->position = *arg2;
70970 }
70971
70972
70973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
70974   void * jresult ;
70975   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70976   Dali::Vector2 *result = 0 ;
70977
70978   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70979   result = (Dali::Vector2 *)& ((arg1)->position);
70980   jresult = (void *)result;
70981   return jresult;
70982 }
70983
70984
70985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
70986   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70987   float arg2 ;
70988
70989   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70990   arg2 = (float)jarg2;
70991   if (arg1) (arg1)->duration = arg2;
70992 }
70993
70994
70995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
70996   float jresult ;
70997   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70998   float result;
70999
71000   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
71001   result = (float) ((arg1)->duration);
71002   jresult = result;
71003   return jresult;
71004 }
71005
71006
71007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
71008   void * jresult ;
71009   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
71010
71011   {
71012     try {
71013       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
71014     } catch (std::out_of_range& e) {
71015       {
71016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71017       };
71018     } catch (std::exception& e) {
71019       {
71020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71021       };
71022     } catch (...) {
71023       {
71024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71025       };
71026     }
71027   }
71028   jresult = (void *)result;
71029   return jresult;
71030 }
71031
71032
71033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
71034   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
71035
71036   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
71037   {
71038     try {
71039       delete arg1;
71040     } catch (std::out_of_range& e) {
71041       {
71042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71043       };
71044     } catch (std::exception& e) {
71045       {
71046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71047       };
71048     } catch (...) {
71049       {
71050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71051       };
71052     }
71053   }
71054 }
71055
71056
71057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
71058   int jresult ;
71059   int result;
71060
71061   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
71062   jresult = (int)result;
71063   return jresult;
71064 }
71065
71066
71067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
71068   int jresult ;
71069   int result;
71070
71071   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
71072   jresult = (int)result;
71073   return jresult;
71074 }
71075
71076
71077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
71078   int jresult ;
71079   int result;
71080
71081   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
71082   jresult = (int)result;
71083   return jresult;
71084 }
71085
71086
71087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
71088   int jresult ;
71089   int result;
71090
71091   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
71092   jresult = (int)result;
71093   return jresult;
71094 }
71095
71096
71097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
71098   int jresult ;
71099   int result;
71100
71101   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
71102   jresult = (int)result;
71103   return jresult;
71104 }
71105
71106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
71107   int jresult ;
71108   int result;
71109
71110   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
71111   jresult = (int)result;
71112   return jresult;
71113 }
71114
71115
71116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
71117   int jresult ;
71118   int result;
71119
71120   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
71121   jresult = (int)result;
71122   return jresult;
71123 }
71124
71125
71126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
71127   int jresult ;
71128   int result;
71129
71130   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
71131   jresult = (int)result;
71132   return jresult;
71133 }
71134
71135
71136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
71137   int jresult ;
71138   int result;
71139
71140   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
71141   jresult = (int)result;
71142   return jresult;
71143 }
71144
71145
71146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
71147   int jresult ;
71148   int result;
71149
71150   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
71151   jresult = (int)result;
71152   return jresult;
71153 }
71154
71155
71156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
71157   int jresult ;
71158   int result;
71159
71160   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
71161   jresult = (int)result;
71162   return jresult;
71163 }
71164
71165
71166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
71167   int jresult ;
71168   int result;
71169
71170   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
71171   jresult = (int)result;
71172   return jresult;
71173 }
71174
71175
71176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
71177   int jresult ;
71178   int result;
71179
71180   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
71181   jresult = (int)result;
71182   return jresult;
71183 }
71184
71185
71186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
71187   int jresult ;
71188   int result;
71189
71190   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
71191   jresult = (int)result;
71192   return jresult;
71193 }
71194
71195
71196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
71197   int jresult ;
71198   int result;
71199
71200   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
71201   jresult = (int)result;
71202   return jresult;
71203 }
71204
71205
71206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
71207   int jresult ;
71208   int result;
71209
71210   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
71211   jresult = (int)result;
71212   return jresult;
71213 }
71214
71215
71216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
71217   int jresult ;
71218   int result;
71219
71220   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
71221   jresult = (int)result;
71222   return jresult;
71223 }
71224
71225
71226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
71227   int jresult ;
71228   int result;
71229
71230   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
71231   jresult = (int)result;
71232   return jresult;
71233 }
71234
71235
71236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
71237   int jresult ;
71238   int result;
71239
71240   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
71241   jresult = (int)result;
71242   return jresult;
71243 }
71244
71245
71246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
71247   int jresult ;
71248   int result;
71249
71250   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
71251   jresult = (int)result;
71252   return jresult;
71253 }
71254
71255
71256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
71257   int jresult ;
71258   int result;
71259
71260   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
71261   jresult = (int)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
71267   int jresult ;
71268   int result;
71269
71270   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
71271   jresult = (int)result;
71272   return jresult;
71273 }
71274
71275
71276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
71277   int jresult ;
71278   int result;
71279
71280   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
71281   jresult = (int)result;
71282   return jresult;
71283 }
71284
71285
71286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
71287   int jresult ;
71288   int result;
71289
71290   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
71291   jresult = (int)result;
71292   return jresult;
71293 }
71294
71295
71296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
71297   int jresult ;
71298   int result;
71299
71300   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
71301   jresult = (int)result;
71302   return jresult;
71303 }
71304
71305
71306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
71307   int jresult ;
71308   int result;
71309
71310   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
71311   jresult = (int)result;
71312   return jresult;
71313 }
71314
71315
71316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
71317   void * jresult ;
71318   Dali::Toolkit::ScrollView::Property *result = 0 ;
71319
71320   {
71321     try {
71322       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
71323     } catch (std::out_of_range& e) {
71324       {
71325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71326       };
71327     } catch (std::exception& e) {
71328       {
71329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71330       };
71331     } catch (...) {
71332       {
71333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71334       };
71335     }
71336   }
71337   jresult = (void *)result;
71338   return jresult;
71339 }
71340
71341
71342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
71343   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
71344
71345   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
71346   {
71347     try {
71348       delete arg1;
71349     } catch (std::out_of_range& e) {
71350       {
71351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71352       };
71353     } catch (std::exception& e) {
71354       {
71355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71356       };
71357     } catch (...) {
71358       {
71359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71360       };
71361     }
71362   }
71363 }
71364
71365
71366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
71367   void * jresult ;
71368   Dali::Toolkit::ScrollView *result = 0 ;
71369
71370   {
71371     try {
71372       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
71373     } catch (std::out_of_range& e) {
71374       {
71375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71376       };
71377     } catch (std::exception& e) {
71378       {
71379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71380       };
71381     } catch (...) {
71382       {
71383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71384       };
71385     }
71386   }
71387   jresult = (void *)result;
71388   return jresult;
71389 }
71390
71391
71392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
71393   void * jresult ;
71394   Dali::Toolkit::ScrollView *arg1 = 0 ;
71395   Dali::Toolkit::ScrollView *result = 0 ;
71396
71397   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71398   if (!arg1) {
71399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
71400     return 0;
71401   }
71402   {
71403     try {
71404       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
71405     } catch (std::out_of_range& e) {
71406       {
71407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71408       };
71409     } catch (std::exception& e) {
71410       {
71411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71412       };
71413     } catch (...) {
71414       {
71415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71416       };
71417     }
71418   }
71419   jresult = (void *)result;
71420   return jresult;
71421 }
71422
71423
71424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
71425   void * jresult ;
71426   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71427   Dali::Toolkit::ScrollView *arg2 = 0 ;
71428   Dali::Toolkit::ScrollView *result = 0 ;
71429
71430   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71431   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
71432   if (!arg2) {
71433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
71434     return 0;
71435   }
71436   {
71437     try {
71438       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
71439     } catch (std::out_of_range& e) {
71440       {
71441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71442       };
71443     } catch (std::exception& e) {
71444       {
71445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71446       };
71447     } catch (...) {
71448       {
71449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71450       };
71451     }
71452   }
71453   jresult = (void *)result;
71454   return jresult;
71455 }
71456
71457
71458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
71459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71460
71461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71462   {
71463     try {
71464       delete arg1;
71465     } catch (std::out_of_range& e) {
71466       {
71467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71468       };
71469     } catch (std::exception& e) {
71470       {
71471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71472       };
71473     } catch (...) {
71474       {
71475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71476       };
71477     }
71478   }
71479 }
71480
71481
71482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
71483   void * jresult ;
71484   Dali::Toolkit::ScrollView result;
71485
71486   {
71487     try {
71488       result = Dali::Toolkit::ScrollView::New();
71489     } catch (std::out_of_range& e) {
71490       {
71491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71492       };
71493     } catch (std::exception& e) {
71494       {
71495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71496       };
71497     } catch (...) {
71498       {
71499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71500       };
71501     }
71502   }
71503   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
71504   return jresult;
71505 }
71506
71507
71508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
71509   void * jresult ;
71510   Dali::BaseHandle arg1 ;
71511   Dali::BaseHandle *argp1 ;
71512   Dali::Toolkit::ScrollView result;
71513
71514   argp1 = (Dali::BaseHandle *)jarg1;
71515   if (!argp1) {
71516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71517     return 0;
71518   }
71519   arg1 = *argp1;
71520   {
71521     try {
71522       result = Dali::Toolkit::ScrollView::DownCast(arg1);
71523     } catch (std::out_of_range& e) {
71524       {
71525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71526       };
71527     } catch (std::exception& e) {
71528       {
71529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71530       };
71531     } catch (...) {
71532       {
71533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71534       };
71535     }
71536   }
71537   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
71538   return jresult;
71539 }
71540
71541
71542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
71543   void * jresult ;
71544   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71545   Dali::AlphaFunction result;
71546
71547   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71548   {
71549     try {
71550       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
71551     } catch (std::out_of_range& e) {
71552       {
71553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71554       };
71555     } catch (std::exception& e) {
71556       {
71557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71558       };
71559     } catch (...) {
71560       {
71561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71562       };
71563     }
71564   }
71565   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
71566   return jresult;
71567 }
71568
71569
71570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
71571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71572   Dali::AlphaFunction arg2 ;
71573   Dali::AlphaFunction *argp2 ;
71574
71575   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71576   argp2 = (Dali::AlphaFunction *)jarg2;
71577   if (!argp2) {
71578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71579     return ;
71580   }
71581   arg2 = *argp2;
71582   {
71583     try {
71584       (arg1)->SetScrollSnapAlphaFunction(arg2);
71585     } catch (std::out_of_range& e) {
71586       {
71587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71588       };
71589     } catch (std::exception& e) {
71590       {
71591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71592       };
71593     } catch (...) {
71594       {
71595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71596       };
71597     }
71598   }
71599 }
71600
71601
71602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
71603   void * jresult ;
71604   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71605   Dali::AlphaFunction result;
71606
71607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71608   {
71609     try {
71610       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
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 = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
71626   return jresult;
71627 }
71628
71629
71630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
71631   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71632   Dali::AlphaFunction arg2 ;
71633   Dali::AlphaFunction *argp2 ;
71634
71635   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71636   argp2 = (Dali::AlphaFunction *)jarg2;
71637   if (!argp2) {
71638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71639     return ;
71640   }
71641   arg2 = *argp2;
71642   {
71643     try {
71644       (arg1)->SetScrollFlickAlphaFunction(arg2);
71645     } catch (std::out_of_range& e) {
71646       {
71647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71648       };
71649     } catch (std::exception& e) {
71650       {
71651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71652       };
71653     } catch (...) {
71654       {
71655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71656       };
71657     }
71658   }
71659 }
71660
71661
71662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
71663   float jresult ;
71664   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71665   float result;
71666
71667   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71668   {
71669     try {
71670       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
71671     } catch (std::out_of_range& e) {
71672       {
71673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (std::exception& e) {
71676       {
71677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71678       };
71679     } catch (...) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71682       };
71683     }
71684   }
71685   jresult = result;
71686   return jresult;
71687 }
71688
71689
71690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
71691   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71692   float arg2 ;
71693
71694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71695   arg2 = (float)jarg2;
71696   {
71697     try {
71698       (arg1)->SetScrollSnapDuration(arg2);
71699     } catch (std::out_of_range& e) {
71700       {
71701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71702       };
71703     } catch (std::exception& e) {
71704       {
71705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71706       };
71707     } catch (...) {
71708       {
71709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71710       };
71711     }
71712   }
71713 }
71714
71715
71716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
71717   float jresult ;
71718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71719   float result;
71720
71721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71722   {
71723     try {
71724       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
71725     } catch (std::out_of_range& e) {
71726       {
71727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71728       };
71729     } catch (std::exception& e) {
71730       {
71731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71732       };
71733     } catch (...) {
71734       {
71735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71736       };
71737     }
71738   }
71739   jresult = result;
71740   return jresult;
71741 }
71742
71743
71744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
71745   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71746   float arg2 ;
71747
71748   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71749   arg2 = (float)jarg2;
71750   {
71751     try {
71752       (arg1)->SetScrollFlickDuration(arg2);
71753     } catch (std::out_of_range& e) {
71754       {
71755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71756       };
71757     } catch (std::exception& e) {
71758       {
71759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71760       };
71761     } catch (...) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71764       };
71765     }
71766   }
71767 }
71768
71769
71770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
71771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71772   Dali::Toolkit::RulerPtr arg2 ;
71773   Dali::Toolkit::RulerPtr *argp2 ;
71774
71775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71776   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
71777   if (!argp2) {
71778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
71779     return ;
71780   }
71781   arg2 = *argp2;
71782   {
71783     try {
71784       (arg1)->SetRulerX(arg2);
71785     } catch (std::out_of_range& e) {
71786       {
71787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71788       };
71789     } catch (std::exception& e) {
71790       {
71791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71792       };
71793     } catch (...) {
71794       {
71795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71796       };
71797     }
71798   }
71799 }
71800
71801
71802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
71803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71804   Dali::Toolkit::RulerPtr arg2 ;
71805   Dali::Toolkit::RulerPtr *argp2 ;
71806
71807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71808   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
71809   if (!argp2) {
71810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
71811     return ;
71812   }
71813   arg2 = *argp2;
71814   {
71815     try {
71816       (arg1)->SetRulerY(arg2);
71817     } catch (std::out_of_range& e) {
71818       {
71819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71820       };
71821     } catch (std::exception& e) {
71822       {
71823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71824       };
71825     } catch (...) {
71826       {
71827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71828       };
71829     }
71830   }
71831 }
71832
71833
71834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
71835   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71836   bool arg2 ;
71837
71838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71839   arg2 = jarg2 ? true : false;
71840   {
71841     try {
71842       (arg1)->SetScrollSensitive(arg2);
71843     } catch (std::out_of_range& e) {
71844       {
71845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71846       };
71847     } catch (std::exception& e) {
71848       {
71849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71850       };
71851     } catch (...) {
71852       {
71853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71854       };
71855     }
71856   }
71857 }
71858
71859
71860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
71861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71862   float arg2 ;
71863   float arg3 ;
71864
71865   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71866   arg2 = (float)jarg2;
71867   arg3 = (float)jarg3;
71868   {
71869     try {
71870       (arg1)->SetMaxOvershoot(arg2,arg3);
71871     } catch (std::out_of_range& e) {
71872       {
71873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71874       };
71875     } catch (std::exception& e) {
71876       {
71877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71878       };
71879     } catch (...) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71882       };
71883     }
71884   }
71885 }
71886
71887
71888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
71889   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71890   Dali::AlphaFunction arg2 ;
71891   Dali::AlphaFunction *argp2 ;
71892
71893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71894   argp2 = (Dali::AlphaFunction *)jarg2;
71895   if (!argp2) {
71896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71897     return ;
71898   }
71899   arg2 = *argp2;
71900   {
71901     try {
71902       (arg1)->SetSnapOvershootAlphaFunction(arg2);
71903     } catch (std::out_of_range& e) {
71904       {
71905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71906       };
71907     } catch (std::exception& e) {
71908       {
71909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71910       };
71911     } catch (...) {
71912       {
71913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71914       };
71915     }
71916   }
71917 }
71918
71919
71920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
71921   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71922   float arg2 ;
71923
71924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71925   arg2 = (float)jarg2;
71926   {
71927     try {
71928       (arg1)->SetSnapOvershootDuration(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_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
71947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71948   bool arg2 ;
71949
71950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71951   arg2 = jarg2 ? true : false;
71952   {
71953     try {
71954       (arg1)->SetActorAutoSnap(arg2);
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71962       };
71963     } catch (...) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71966       };
71967     }
71968   }
71969 }
71970
71971
71972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
71973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71974   bool arg2 ;
71975
71976   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71977   arg2 = jarg2 ? true : false;
71978   {
71979     try {
71980       (arg1)->SetWrapMode(arg2);
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 int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
71999   int jresult ;
72000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72001   int result;
72002
72003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72004   {
72005     try {
72006       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
72007     } catch (std::out_of_range& e) {
72008       {
72009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72010       };
72011     } catch (std::exception& e) {
72012       {
72013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72014       };
72015     } catch (...) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72018       };
72019     }
72020   }
72021   jresult = result;
72022   return jresult;
72023 }
72024
72025
72026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
72027   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72028   int arg2 ;
72029
72030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72031   arg2 = (int)jarg2;
72032   {
72033     try {
72034       (arg1)->SetScrollUpdateDistance(arg2);
72035     } catch (std::out_of_range& e) {
72036       {
72037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72038       };
72039     } catch (std::exception& e) {
72040       {
72041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72042       };
72043     } catch (...) {
72044       {
72045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72046       };
72047     }
72048   }
72049 }
72050
72051
72052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
72053   unsigned int jresult ;
72054   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72055   bool result;
72056
72057   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72058   {
72059     try {
72060       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
72061     } catch (std::out_of_range& e) {
72062       {
72063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72064       };
72065     } catch (std::exception& e) {
72066       {
72067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72068       };
72069     } catch (...) {
72070       {
72071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72072       };
72073     }
72074   }
72075   jresult = result;
72076   return jresult;
72077 }
72078
72079
72080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
72081   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72082   bool arg2 ;
72083
72084   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72085   arg2 = jarg2 ? true : false;
72086   {
72087     try {
72088       (arg1)->SetAxisAutoLock(arg2);
72089     } catch (std::out_of_range& e) {
72090       {
72091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72092       };
72093     } catch (std::exception& e) {
72094       {
72095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72096       };
72097     } catch (...) {
72098       {
72099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72100       };
72101     }
72102   }
72103 }
72104
72105
72106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
72107   float jresult ;
72108   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72109   float result;
72110
72111   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72112   {
72113     try {
72114       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
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 void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
72135   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72136   float arg2 ;
72137
72138   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72139   arg2 = (float)jarg2;
72140   {
72141     try {
72142       (arg1)->SetAxisAutoLockGradient(arg2);
72143     } catch (std::out_of_range& e) {
72144       {
72145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72146       };
72147     } catch (std::exception& e) {
72148       {
72149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72150       };
72151     } catch (...) {
72152       {
72153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72154       };
72155     }
72156   }
72157 }
72158
72159
72160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
72161   float jresult ;
72162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72163   float result;
72164
72165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72166   {
72167     try {
72168       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
72169     } catch (std::out_of_range& e) {
72170       {
72171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72172       };
72173     } catch (std::exception& e) {
72174       {
72175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72176       };
72177     } catch (...) {
72178       {
72179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72180       };
72181     }
72182   }
72183   jresult = result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
72189   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72190   float arg2 ;
72191
72192   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72193   arg2 = (float)jarg2;
72194   {
72195     try {
72196       (arg1)->SetFrictionCoefficient(arg2);
72197     } catch (std::out_of_range& e) {
72198       {
72199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72200       };
72201     } catch (std::exception& e) {
72202       {
72203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72204       };
72205     } catch (...) {
72206       {
72207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72208       };
72209     }
72210   }
72211 }
72212
72213
72214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
72215   float jresult ;
72216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72217   float result;
72218
72219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72220   {
72221     try {
72222       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
72223     } catch (std::out_of_range& e) {
72224       {
72225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72226       };
72227     } catch (std::exception& e) {
72228       {
72229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72230       };
72231     } catch (...) {
72232       {
72233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72234       };
72235     }
72236   }
72237   jresult = result;
72238   return jresult;
72239 }
72240
72241
72242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
72243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72244   float arg2 ;
72245
72246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72247   arg2 = (float)jarg2;
72248   {
72249     try {
72250       (arg1)->SetFlickSpeedCoefficient(arg2);
72251     } catch (std::out_of_range& e) {
72252       {
72253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72254       };
72255     } catch (std::exception& e) {
72256       {
72257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72258       };
72259     } catch (...) {
72260       {
72261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72262       };
72263     }
72264   }
72265 }
72266
72267
72268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
72269   void * jresult ;
72270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72271   Dali::Vector2 result;
72272
72273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72274   {
72275     try {
72276       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
72277     } catch (std::out_of_range& e) {
72278       {
72279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72280       };
72281     } catch (std::exception& e) {
72282       {
72283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72284       };
72285     } catch (...) {
72286       {
72287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72288       };
72289     }
72290   }
72291   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72292   return jresult;
72293 }
72294
72295
72296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
72297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72298   Dali::Vector2 *arg2 = 0 ;
72299
72300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72301   arg2 = (Dali::Vector2 *)jarg2;
72302   if (!arg2) {
72303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72304     return ;
72305   }
72306   {
72307     try {
72308       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
72309     } catch (std::out_of_range& e) {
72310       {
72311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72312       };
72313     } catch (std::exception& e) {
72314       {
72315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72316       };
72317     } catch (...) {
72318       {
72319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72320       };
72321     }
72322   }
72323 }
72324
72325
72326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
72327   float jresult ;
72328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72329   float result;
72330
72331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72332   {
72333     try {
72334       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
72335     } catch (std::out_of_range& e) {
72336       {
72337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72338       };
72339     } catch (std::exception& e) {
72340       {
72341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72342       };
72343     } catch (...) {
72344       {
72345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72346       };
72347     }
72348   }
72349   jresult = result;
72350   return jresult;
72351 }
72352
72353
72354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
72355   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72356   float arg2 ;
72357
72358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72359   arg2 = (float)jarg2;
72360   {
72361     try {
72362       (arg1)->SetMinimumSpeedForFlick(arg2);
72363     } catch (std::out_of_range& e) {
72364       {
72365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72366       };
72367     } catch (std::exception& e) {
72368       {
72369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72374       };
72375     }
72376   }
72377 }
72378
72379
72380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
72381   float jresult ;
72382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72383   float result;
72384
72385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72386   {
72387     try {
72388       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72396       };
72397     } catch (...) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72400       };
72401     }
72402   }
72403   jresult = result;
72404   return jresult;
72405 }
72406
72407
72408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
72409   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72410   float arg2 ;
72411
72412   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72413   arg2 = (float)jarg2;
72414   {
72415     try {
72416       (arg1)->SetMaxFlickSpeed(arg2);
72417     } catch (std::out_of_range& e) {
72418       {
72419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72420       };
72421     } catch (std::exception& e) {
72422       {
72423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72424       };
72425     } catch (...) {
72426       {
72427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72428       };
72429     }
72430   }
72431 }
72432
72433
72434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
72435   void * jresult ;
72436   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72437   Dali::Vector2 result;
72438
72439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72440   {
72441     try {
72442       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
72443     } catch (std::out_of_range& e) {
72444       {
72445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72446       };
72447     } catch (std::exception& e) {
72448       {
72449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72450       };
72451     } catch (...) {
72452       {
72453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72454       };
72455     }
72456   }
72457   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72458   return jresult;
72459 }
72460
72461
72462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
72463   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72464   Dali::Vector2 arg2 ;
72465   Dali::Vector2 *argp2 ;
72466
72467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72468   argp2 = (Dali::Vector2 *)jarg2;
72469   if (!argp2) {
72470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
72471     return ;
72472   }
72473   arg2 = *argp2;
72474   {
72475     try {
72476       (arg1)->SetWheelScrollDistanceStep(arg2);
72477     } catch (std::out_of_range& e) {
72478       {
72479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72480       };
72481     } catch (std::exception& e) {
72482       {
72483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72484       };
72485     } catch (...) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72488       };
72489     }
72490   }
72491 }
72492
72493
72494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
72495   void * jresult ;
72496   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72497   Dali::Vector2 result;
72498
72499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72500   {
72501     try {
72502       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
72503     } catch (std::out_of_range& e) {
72504       {
72505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72506       };
72507     } catch (std::exception& e) {
72508       {
72509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72510       };
72511     } catch (...) {
72512       {
72513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72514       };
72515     }
72516   }
72517   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72518   return jresult;
72519 }
72520
72521
72522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
72523   unsigned int jresult ;
72524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72525   unsigned int result;
72526
72527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72528   {
72529     try {
72530       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
72531     } catch (std::out_of_range& e) {
72532       {
72533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72534       };
72535     } catch (std::exception& e) {
72536       {
72537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72538       };
72539     } catch (...) {
72540       {
72541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72542       };
72543     }
72544   }
72545   jresult = result;
72546   return jresult;
72547 }
72548
72549
72550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
72551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72552   Dali::Vector2 *arg2 = 0 ;
72553
72554   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72555   arg2 = (Dali::Vector2 *)jarg2;
72556   if (!arg2) {
72557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72558     return ;
72559   }
72560   {
72561     try {
72562       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
72563     } catch (std::out_of_range& e) {
72564       {
72565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72566       };
72567     } catch (std::exception& e) {
72568       {
72569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72570       };
72571     } catch (...) {
72572       {
72573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72574       };
72575     }
72576   }
72577 }
72578
72579
72580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
72581   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72582   Dali::Vector2 *arg2 = 0 ;
72583   float arg3 ;
72584
72585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72586   arg2 = (Dali::Vector2 *)jarg2;
72587   if (!arg2) {
72588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72589     return ;
72590   }
72591   arg3 = (float)jarg3;
72592   {
72593     try {
72594       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
72595     } catch (std::out_of_range& e) {
72596       {
72597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72598       };
72599     } catch (std::exception& e) {
72600       {
72601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72602       };
72603     } catch (...) {
72604       {
72605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72606       };
72607     }
72608   }
72609 }
72610
72611
72612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
72613   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72614   Dali::Vector2 *arg2 = 0 ;
72615   float arg3 ;
72616   Dali::AlphaFunction arg4 ;
72617   Dali::AlphaFunction *argp4 ;
72618
72619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72620   arg2 = (Dali::Vector2 *)jarg2;
72621   if (!arg2) {
72622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72623     return ;
72624   }
72625   arg3 = (float)jarg3;
72626   argp4 = (Dali::AlphaFunction *)jarg4;
72627   if (!argp4) {
72628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72629     return ;
72630   }
72631   arg4 = *argp4;
72632   {
72633     try {
72634       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
72635     } catch (std::out_of_range& e) {
72636       {
72637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72638       };
72639     } catch (std::exception& e) {
72640       {
72641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72642       };
72643     } catch (...) {
72644       {
72645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72646       };
72647     }
72648   }
72649 }
72650
72651
72652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
72653   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72654   Dali::Vector2 *arg2 = 0 ;
72655   float arg3 ;
72656   Dali::Toolkit::DirectionBias arg4 ;
72657   Dali::Toolkit::DirectionBias arg5 ;
72658
72659   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72660   arg2 = (Dali::Vector2 *)jarg2;
72661   if (!arg2) {
72662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72663     return ;
72664   }
72665   arg3 = (float)jarg3;
72666   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
72667   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
72668   {
72669     try {
72670       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
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_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
72689   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72690   Dali::Vector2 *arg2 = 0 ;
72691   float arg3 ;
72692   Dali::AlphaFunction arg4 ;
72693   Dali::Toolkit::DirectionBias arg5 ;
72694   Dali::Toolkit::DirectionBias arg6 ;
72695   Dali::AlphaFunction *argp4 ;
72696
72697   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72698   arg2 = (Dali::Vector2 *)jarg2;
72699   if (!arg2) {
72700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72701     return ;
72702   }
72703   arg3 = (float)jarg3;
72704   argp4 = (Dali::AlphaFunction *)jarg4;
72705   if (!argp4) {
72706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72707     return ;
72708   }
72709   arg4 = *argp4;
72710   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
72711   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
72712   {
72713     try {
72714       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
72715     } catch (std::out_of_range& e) {
72716       {
72717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72718       };
72719     } catch (std::exception& e) {
72720       {
72721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72722       };
72723     } catch (...) {
72724       {
72725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72726       };
72727     }
72728   }
72729 }
72730
72731
72732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
72733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72734   unsigned int arg2 ;
72735
72736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72737   arg2 = (unsigned int)jarg2;
72738   {
72739     try {
72740       (arg1)->ScrollTo(arg2);
72741     } catch (std::out_of_range& e) {
72742       {
72743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72744       };
72745     } catch (std::exception& e) {
72746       {
72747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72748       };
72749     } catch (...) {
72750       {
72751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72752       };
72753     }
72754   }
72755 }
72756
72757
72758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
72759   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72760   unsigned int arg2 ;
72761   float arg3 ;
72762
72763   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72764   arg2 = (unsigned int)jarg2;
72765   arg3 = (float)jarg3;
72766   {
72767     try {
72768       (arg1)->ScrollTo(arg2,arg3);
72769     } catch (std::out_of_range& e) {
72770       {
72771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72772       };
72773     } catch (std::exception& e) {
72774       {
72775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72776       };
72777     } catch (...) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72780       };
72781     }
72782   }
72783 }
72784
72785
72786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
72787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72788   unsigned int arg2 ;
72789   float arg3 ;
72790   Dali::Toolkit::DirectionBias arg4 ;
72791
72792   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72793   arg2 = (unsigned int)jarg2;
72794   arg3 = (float)jarg3;
72795   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
72796   {
72797     try {
72798       (arg1)->ScrollTo(arg2,arg3,arg4);
72799     } catch (std::out_of_range& e) {
72800       {
72801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72802       };
72803     } catch (std::exception& e) {
72804       {
72805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72806       };
72807     } catch (...) {
72808       {
72809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72810       };
72811     }
72812   }
72813 }
72814
72815
72816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
72817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72818   Dali::Actor *arg2 = 0 ;
72819
72820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72821   arg2 = (Dali::Actor *)jarg2;
72822   if (!arg2) {
72823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72824     return ;
72825   }
72826   {
72827     try {
72828       (arg1)->ScrollTo(*arg2);
72829     } catch (std::out_of_range& e) {
72830       {
72831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72832       };
72833     } catch (std::exception& e) {
72834       {
72835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72836       };
72837     } catch (...) {
72838       {
72839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72840       };
72841     }
72842   }
72843 }
72844
72845
72846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
72847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72848   Dali::Actor *arg2 = 0 ;
72849   float arg3 ;
72850
72851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72852   arg2 = (Dali::Actor *)jarg2;
72853   if (!arg2) {
72854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72855     return ;
72856   }
72857   arg3 = (float)jarg3;
72858   {
72859     try {
72860       (arg1)->ScrollTo(*arg2,arg3);
72861     } catch (std::out_of_range& e) {
72862       {
72863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72864       };
72865     } catch (std::exception& e) {
72866       {
72867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72868       };
72869     } catch (...) {
72870       {
72871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72872       };
72873     }
72874   }
72875 }
72876
72877
72878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
72879   unsigned int jresult ;
72880   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72881   bool result;
72882
72883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72884   {
72885     try {
72886       result = (bool)(arg1)->ScrollToSnapPoint();
72887     } catch (std::out_of_range& e) {
72888       {
72889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72890       };
72891     } catch (std::exception& e) {
72892       {
72893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72898       };
72899     }
72900   }
72901   jresult = result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
72907   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72908   Dali::Constraint arg2 ;
72909   Dali::Constraint *argp2 ;
72910
72911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72912   argp2 = (Dali::Constraint *)jarg2;
72913   if (!argp2) {
72914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
72915     return ;
72916   }
72917   arg2 = *argp2;
72918   {
72919     try {
72920       (arg1)->ApplyConstraintToChildren(arg2);
72921     } catch (std::out_of_range& e) {
72922       {
72923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72924       };
72925     } catch (std::exception& e) {
72926       {
72927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72928       };
72929     } catch (...) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72932       };
72933     }
72934   }
72935 }
72936
72937
72938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
72939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72940
72941   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72942   {
72943     try {
72944       (arg1)->RemoveConstraintsFromChildren();
72945     } catch (std::out_of_range& e) {
72946       {
72947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72948       };
72949     } catch (std::exception& e) {
72950       {
72951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72952       };
72953     } catch (...) {
72954       {
72955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72956       };
72957     }
72958   }
72959 }
72960
72961
72962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
72963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72964   Dali::Toolkit::ScrollViewEffect arg2 ;
72965   Dali::Toolkit::ScrollViewEffect *argp2 ;
72966
72967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72968   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
72969   if (!argp2) {
72970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
72971     return ;
72972   }
72973   arg2 = *argp2;
72974   {
72975     try {
72976       (arg1)->ApplyEffect(arg2);
72977     } catch (std::out_of_range& e) {
72978       {
72979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72980       };
72981     } catch (std::exception& e) {
72982       {
72983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72984       };
72985     } catch (...) {
72986       {
72987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72988       };
72989     }
72990   }
72991 }
72992
72993
72994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
72995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72996   Dali::Toolkit::ScrollViewEffect arg2 ;
72997   Dali::Toolkit::ScrollViewEffect *argp2 ;
72998
72999   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73000   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
73001   if (!argp2) {
73002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
73003     return ;
73004   }
73005   arg2 = *argp2;
73006   {
73007     try {
73008       (arg1)->RemoveEffect(arg2);
73009     } catch (std::out_of_range& e) {
73010       {
73011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73012       };
73013     } catch (std::exception& e) {
73014       {
73015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73016       };
73017     } catch (...) {
73018       {
73019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73020       };
73021     }
73022   }
73023 }
73024
73025
73026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
73027   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73028
73029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73030   {
73031     try {
73032       (arg1)->RemoveAllEffects();
73033     } catch (std::out_of_range& e) {
73034       {
73035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73036       };
73037     } catch (std::exception& e) {
73038       {
73039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73040       };
73041     } catch (...) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73044       };
73045     }
73046   }
73047 }
73048
73049
73050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
73051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73052   Dali::Actor arg2 ;
73053   Dali::Actor *argp2 ;
73054
73055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73056   argp2 = (Dali::Actor *)jarg2;
73057   if (!argp2) {
73058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73059     return ;
73060   }
73061   arg2 = *argp2;
73062   {
73063     try {
73064       (arg1)->BindActor(arg2);
73065     } catch (std::out_of_range& e) {
73066       {
73067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73068       };
73069     } catch (std::exception& e) {
73070       {
73071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73072       };
73073     } catch (...) {
73074       {
73075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73076       };
73077     }
73078   }
73079 }
73080
73081
73082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
73083   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73084   Dali::Actor arg2 ;
73085   Dali::Actor *argp2 ;
73086
73087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73088   argp2 = (Dali::Actor *)jarg2;
73089   if (!argp2) {
73090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73091     return ;
73092   }
73093   arg2 = *argp2;
73094   {
73095     try {
73096       (arg1)->UnbindActor(arg2);
73097     } catch (std::out_of_range& e) {
73098       {
73099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73100       };
73101     } catch (std::exception& e) {
73102       {
73103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73104       };
73105     } catch (...) {
73106       {
73107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73108       };
73109     }
73110   }
73111 }
73112
73113
73114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
73115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73116   Dali::Radian arg2 ;
73117   Dali::Radian arg3 ;
73118   Dali::Radian *argp2 ;
73119   Dali::Radian *argp3 ;
73120
73121   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73122   argp2 = (Dali::Radian *)jarg2;
73123   if (!argp2) {
73124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73125     return ;
73126   }
73127   arg2 = *argp2;
73128   argp3 = (Dali::Radian *)jarg3;
73129   if (!argp3) {
73130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73131     return ;
73132   }
73133   arg3 = *argp3;
73134   {
73135     try {
73136       (arg1)->SetScrollingDirection(arg2,arg3);
73137     } catch (std::out_of_range& e) {
73138       {
73139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73140       };
73141     } catch (std::exception& e) {
73142       {
73143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73144       };
73145     } catch (...) {
73146       {
73147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73148       };
73149     }
73150   }
73151 }
73152
73153
73154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
73155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73156   Dali::Radian arg2 ;
73157   Dali::Radian *argp2 ;
73158
73159   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73160   argp2 = (Dali::Radian *)jarg2;
73161   if (!argp2) {
73162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73163     return ;
73164   }
73165   arg2 = *argp2;
73166   {
73167     try {
73168       (arg1)->SetScrollingDirection(arg2);
73169     } catch (std::out_of_range& e) {
73170       {
73171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73172       };
73173     } catch (std::exception& e) {
73174       {
73175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73176       };
73177     } catch (...) {
73178       {
73179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73180       };
73181     }
73182   }
73183 }
73184
73185
73186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
73187   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73188   Dali::Radian arg2 ;
73189   Dali::Radian *argp2 ;
73190
73191   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73192   argp2 = (Dali::Radian *)jarg2;
73193   if (!argp2) {
73194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73195     return ;
73196   }
73197   arg2 = *argp2;
73198   {
73199     try {
73200       (arg1)->RemoveScrollingDirection(arg2);
73201     } catch (std::out_of_range& e) {
73202       {
73203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73204       };
73205     } catch (std::exception& e) {
73206       {
73207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73208       };
73209     } catch (...) {
73210       {
73211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73212       };
73213     }
73214   }
73215 }
73216
73217
73218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
73219   void * jresult ;
73220   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73221   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
73222
73223   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73224   {
73225     try {
73226       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
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 int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
73247   int jresult ;
73248   int result;
73249
73250   result = (int)Dali::Toolkit::TableView::Property::ROWS;
73251   jresult = (int)result;
73252   return jresult;
73253 }
73254
73255
73256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
73257   int jresult ;
73258   int result;
73259
73260   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
73261   jresult = (int)result;
73262   return jresult;
73263 }
73264
73265
73266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
73267   int jresult ;
73268   int result;
73269
73270   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
73271   jresult = (int)result;
73272   return jresult;
73273 }
73274
73275
73276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
73277   int jresult ;
73278   int result;
73279
73280   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
73281   jresult = (int)result;
73282   return jresult;
73283 }
73284
73285
73286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
73287   int jresult ;
73288   int result;
73289
73290   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
73291   jresult = (int)result;
73292   return jresult;
73293 }
73294
73295
73296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
73297   void * jresult ;
73298   Dali::Toolkit::TableView::Property *result = 0 ;
73299
73300   {
73301     try {
73302       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
73303     } catch (std::out_of_range& e) {
73304       {
73305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73306       };
73307     } catch (std::exception& e) {
73308       {
73309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73310       };
73311     } catch (...) {
73312       {
73313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73314       };
73315     }
73316   }
73317   jresult = (void *)result;
73318   return jresult;
73319 }
73320
73321
73322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
73323   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
73324
73325   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
73326   {
73327     try {
73328       delete arg1;
73329     } catch (std::out_of_range& e) {
73330       {
73331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73332       };
73333     } catch (std::exception& e) {
73334       {
73335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73336       };
73337     } catch (...) {
73338       {
73339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73340       };
73341     }
73342   }
73343 }
73344
73345
73346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
73347   int jresult ;
73348   int result;
73349
73350   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
73351   jresult = (int)result;
73352   return jresult;
73353 }
73354
73355
73356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
73357   int jresult ;
73358   int result;
73359
73360   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
73361   jresult = (int)result;
73362   return jresult;
73363 }
73364
73365
73366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
73367   int jresult ;
73368   int result;
73369
73370   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
73371   jresult = (int)result;
73372   return jresult;
73373 }
73374
73375
73376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
73377   int jresult ;
73378   int result;
73379
73380   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
73381   jresult = (int)result;
73382   return jresult;
73383 }
73384
73385
73386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
73387   int jresult ;
73388   int result;
73389
73390   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
73391   jresult = (int)result;
73392   return jresult;
73393 }
73394
73395
73396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
73397   void * jresult ;
73398   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
73399
73400   {
73401     try {
73402       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
73403     } catch (std::out_of_range& e) {
73404       {
73405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73406       };
73407     } catch (std::exception& e) {
73408       {
73409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73410       };
73411     } catch (...) {
73412       {
73413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73414       };
73415     }
73416   }
73417   jresult = (void *)result;
73418   return jresult;
73419 }
73420
73421
73422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
73423   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
73424
73425   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
73426   {
73427     try {
73428       delete arg1;
73429     } catch (std::out_of_range& e) {
73430       {
73431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73432       };
73433     } catch (std::exception& e) {
73434       {
73435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73436       };
73437     } catch (...) {
73438       {
73439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73440       };
73441     }
73442   }
73443 }
73444
73445
73446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
73447   void * jresult ;
73448   unsigned int arg1 ;
73449   unsigned int arg2 ;
73450   unsigned int arg3 ;
73451   unsigned int arg4 ;
73452   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73453
73454   arg1 = (unsigned int)jarg1;
73455   arg2 = (unsigned int)jarg2;
73456   arg3 = (unsigned int)jarg3;
73457   arg4 = (unsigned int)jarg4;
73458   {
73459     try {
73460       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
73461     } catch (std::out_of_range& e) {
73462       {
73463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73464       };
73465     } catch (std::exception& e) {
73466       {
73467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73468       };
73469     } catch (...) {
73470       {
73471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73472       };
73473     }
73474   }
73475   jresult = (void *)result;
73476   return jresult;
73477 }
73478
73479
73480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
73481   void * jresult ;
73482   unsigned int arg1 ;
73483   unsigned int arg2 ;
73484   unsigned int arg3 ;
73485   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73486
73487   arg1 = (unsigned int)jarg1;
73488   arg2 = (unsigned int)jarg2;
73489   arg3 = (unsigned int)jarg3;
73490   {
73491     try {
73492       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
73493     } catch (std::out_of_range& e) {
73494       {
73495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73496       };
73497     } catch (std::exception& e) {
73498       {
73499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73500       };
73501     } catch (...) {
73502       {
73503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73504       };
73505     }
73506   }
73507   jresult = (void *)result;
73508   return jresult;
73509 }
73510
73511
73512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
73513   void * jresult ;
73514   unsigned int arg1 ;
73515   unsigned int arg2 ;
73516   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73517
73518   arg1 = (unsigned int)jarg1;
73519   arg2 = (unsigned int)jarg2;
73520   {
73521     try {
73522       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
73523     } catch (std::out_of_range& e) {
73524       {
73525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73526       };
73527     } catch (std::exception& e) {
73528       {
73529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73530       };
73531     } catch (...) {
73532       {
73533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73534       };
73535     }
73536   }
73537   jresult = (void *)result;
73538   return jresult;
73539 }
73540
73541
73542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
73543   void * jresult ;
73544   unsigned int arg1 ;
73545   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73546
73547   arg1 = (unsigned int)jarg1;
73548   {
73549     try {
73550       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
73551     } catch (std::out_of_range& e) {
73552       {
73553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73554       };
73555     } catch (std::exception& e) {
73556       {
73557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73558       };
73559     } catch (...) {
73560       {
73561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73562       };
73563     }
73564   }
73565   jresult = (void *)result;
73566   return jresult;
73567 }
73568
73569
73570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
73571   void * jresult ;
73572   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73573
73574   {
73575     try {
73576       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
73577     } catch (std::out_of_range& e) {
73578       {
73579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73580       };
73581     } catch (std::exception& e) {
73582       {
73583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73584       };
73585     } catch (...) {
73586       {
73587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73588       };
73589     }
73590   }
73591   jresult = (void *)result;
73592   return jresult;
73593 }
73594
73595
73596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
73597   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73598   unsigned int arg2 ;
73599
73600   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73601   arg2 = (unsigned int)jarg2;
73602   if (arg1) (arg1)->rowIndex = arg2;
73603 }
73604
73605
73606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
73607   unsigned int jresult ;
73608   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73609   unsigned int result;
73610
73611   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73612   result = (unsigned int) ((arg1)->rowIndex);
73613   jresult = result;
73614   return jresult;
73615 }
73616
73617
73618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
73619   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73620   unsigned int arg2 ;
73621
73622   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73623   arg2 = (unsigned int)jarg2;
73624   if (arg1) (arg1)->columnIndex = arg2;
73625 }
73626
73627
73628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
73629   unsigned int jresult ;
73630   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73631   unsigned int result;
73632
73633   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73634   result = (unsigned int) ((arg1)->columnIndex);
73635   jresult = result;
73636   return jresult;
73637 }
73638
73639
73640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
73641   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73642   unsigned int arg2 ;
73643
73644   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73645   arg2 = (unsigned int)jarg2;
73646   if (arg1) (arg1)->rowSpan = arg2;
73647 }
73648
73649
73650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
73651   unsigned int jresult ;
73652   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73653   unsigned int result;
73654
73655   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73656   result = (unsigned int) ((arg1)->rowSpan);
73657   jresult = result;
73658   return jresult;
73659 }
73660
73661
73662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
73663   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73664   unsigned int arg2 ;
73665
73666   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73667   arg2 = (unsigned int)jarg2;
73668   if (arg1) (arg1)->columnSpan = arg2;
73669 }
73670
73671
73672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
73673   unsigned int jresult ;
73674   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73675   unsigned int result;
73676
73677   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73678   result = (unsigned int) ((arg1)->columnSpan);
73679   jresult = result;
73680   return jresult;
73681 }
73682
73683
73684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
73685   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73686
73687   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73688   {
73689     try {
73690       delete arg1;
73691     } catch (std::out_of_range& e) {
73692       {
73693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73694       };
73695     } catch (std::exception& e) {
73696       {
73697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73698       };
73699     } catch (...) {
73700       {
73701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73702       };
73703     }
73704   }
73705 }
73706
73707
73708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
73709   void * jresult ;
73710   Dali::Toolkit::TableView *result = 0 ;
73711
73712   {
73713     try {
73714       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
73715     } catch (std::out_of_range& e) {
73716       {
73717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73718       };
73719     } catch (std::exception& e) {
73720       {
73721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73722       };
73723     } catch (...) {
73724       {
73725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73726       };
73727     }
73728   }
73729   jresult = (void *)result;
73730   return jresult;
73731 }
73732
73733
73734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
73735   void * jresult ;
73736   Dali::Toolkit::TableView *arg1 = 0 ;
73737   Dali::Toolkit::TableView *result = 0 ;
73738
73739   arg1 = (Dali::Toolkit::TableView *)jarg1;
73740   if (!arg1) {
73741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
73742     return 0;
73743   }
73744   {
73745     try {
73746       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
73747     } catch (std::out_of_range& e) {
73748       {
73749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73750       };
73751     } catch (std::exception& e) {
73752       {
73753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73754       };
73755     } catch (...) {
73756       {
73757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73758       };
73759     }
73760   }
73761   jresult = (void *)result;
73762   return jresult;
73763 }
73764
73765
73766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
73767   void * jresult ;
73768   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73769   Dali::Toolkit::TableView *arg2 = 0 ;
73770   Dali::Toolkit::TableView *result = 0 ;
73771
73772   arg1 = (Dali::Toolkit::TableView *)jarg1;
73773   arg2 = (Dali::Toolkit::TableView *)jarg2;
73774   if (!arg2) {
73775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
73776     return 0;
73777   }
73778   {
73779     try {
73780       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
73781     } catch (std::out_of_range& e) {
73782       {
73783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73784       };
73785     } catch (std::exception& e) {
73786       {
73787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73788       };
73789     } catch (...) {
73790       {
73791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73792       };
73793     }
73794   }
73795   jresult = (void *)result;
73796   return jresult;
73797 }
73798
73799
73800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
73801   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73802
73803   arg1 = (Dali::Toolkit::TableView *)jarg1;
73804   {
73805     try {
73806       delete arg1;
73807     } catch (std::out_of_range& e) {
73808       {
73809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73810       };
73811     } catch (std::exception& e) {
73812       {
73813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73814       };
73815     } catch (...) {
73816       {
73817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73818       };
73819     }
73820   }
73821 }
73822
73823
73824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
73825   void * jresult ;
73826   unsigned int arg1 ;
73827   unsigned int arg2 ;
73828   Dali::Toolkit::TableView result;
73829
73830   arg1 = (unsigned int)jarg1;
73831   arg2 = (unsigned int)jarg2;
73832   {
73833     try {
73834       result = Dali::Toolkit::TableView::New(arg1,arg2);
73835     } catch (std::out_of_range& e) {
73836       {
73837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73838       };
73839     } catch (std::exception& e) {
73840       {
73841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73842       };
73843     } catch (...) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73846       };
73847     }
73848   }
73849   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
73850   return jresult;
73851 }
73852
73853
73854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
73855   void * jresult ;
73856   Dali::BaseHandle arg1 ;
73857   Dali::BaseHandle *argp1 ;
73858   Dali::Toolkit::TableView result;
73859
73860   argp1 = (Dali::BaseHandle *)jarg1;
73861   if (!argp1) {
73862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73863     return 0;
73864   }
73865   arg1 = *argp1;
73866   {
73867     try {
73868       result = Dali::Toolkit::TableView::DownCast(arg1);
73869     } catch (std::out_of_range& e) {
73870       {
73871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73872       };
73873     } catch (std::exception& e) {
73874       {
73875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73876       };
73877     } catch (...) {
73878       {
73879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73880       };
73881     }
73882   }
73883   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
73884   return jresult;
73885 }
73886
73887
73888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
73889   unsigned int jresult ;
73890   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73891   Dali::Actor arg2 ;
73892   Dali::Toolkit::TableView::CellPosition arg3 ;
73893   Dali::Actor *argp2 ;
73894   Dali::Toolkit::TableView::CellPosition *argp3 ;
73895   bool result;
73896
73897   arg1 = (Dali::Toolkit::TableView *)jarg1;
73898   argp2 = (Dali::Actor *)jarg2;
73899   if (!argp2) {
73900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73901     return 0;
73902   }
73903   arg2 = *argp2;
73904   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
73905   if (!argp3) {
73906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73907     return 0;
73908   }
73909   arg3 = *argp3;
73910   {
73911     try {
73912       result = (bool)(arg1)->AddChild(arg2,arg3);
73913     } catch (std::out_of_range& e) {
73914       {
73915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73916       };
73917     } catch (std::exception& e) {
73918       {
73919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73920       };
73921     } catch (...) {
73922       {
73923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73924       };
73925     }
73926   }
73927   jresult = result;
73928   return jresult;
73929 }
73930
73931
73932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
73933   void * jresult ;
73934   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73935   Dali::Toolkit::TableView::CellPosition arg2 ;
73936   Dali::Toolkit::TableView::CellPosition *argp2 ;
73937   Dali::Actor result;
73938
73939   arg1 = (Dali::Toolkit::TableView *)jarg1;
73940   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
73941   if (!argp2) {
73942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73943     return 0;
73944   }
73945   arg2 = *argp2;
73946   {
73947     try {
73948       result = (arg1)->GetChildAt(arg2);
73949     } catch (std::out_of_range& e) {
73950       {
73951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73952       };
73953     } catch (std::exception& e) {
73954       {
73955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73956       };
73957     } catch (...) {
73958       {
73959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73960       };
73961     }
73962   }
73963   jresult = new Dali::Actor((const Dali::Actor &)result);
73964   return jresult;
73965 }
73966
73967
73968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
73969   void * jresult ;
73970   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73971   Dali::Toolkit::TableView::CellPosition arg2 ;
73972   Dali::Toolkit::TableView::CellPosition *argp2 ;
73973   Dali::Actor result;
73974
73975   arg1 = (Dali::Toolkit::TableView *)jarg1;
73976   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
73977   if (!argp2) {
73978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73979     return 0;
73980   }
73981   arg2 = *argp2;
73982   {
73983     try {
73984       result = (arg1)->RemoveChildAt(arg2);
73985     } catch (std::out_of_range& e) {
73986       {
73987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73988       };
73989     } catch (std::exception& e) {
73990       {
73991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73992       };
73993     } catch (...) {
73994       {
73995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73996       };
73997     }
73998   }
73999   jresult = new Dali::Actor((const Dali::Actor &)result);
74000   return jresult;
74001 }
74002
74003
74004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
74005   unsigned int jresult ;
74006   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74007   Dali::Actor arg2 ;
74008   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
74009   Dali::Actor *argp2 ;
74010   bool result;
74011
74012   arg1 = (Dali::Toolkit::TableView *)jarg1;
74013   argp2 = (Dali::Actor *)jarg2;
74014   if (!argp2) {
74015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74016     return 0;
74017   }
74018   arg2 = *argp2;
74019   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
74020   if (!arg3) {
74021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
74022     return 0;
74023   }
74024   {
74025     try {
74026       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
74027     } catch (std::out_of_range& e) {
74028       {
74029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74030       };
74031     } catch (std::exception& e) {
74032       {
74033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74034       };
74035     } catch (...) {
74036       {
74037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74038       };
74039     }
74040   }
74041   jresult = result;
74042   return jresult;
74043 }
74044
74045
74046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
74047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74048   unsigned int arg2 ;
74049
74050   arg1 = (Dali::Toolkit::TableView *)jarg1;
74051   arg2 = (unsigned int)jarg2;
74052   {
74053     try {
74054       (arg1)->InsertRow(arg2);
74055     } catch (std::out_of_range& e) {
74056       {
74057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74058       };
74059     } catch (std::exception& e) {
74060       {
74061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74062       };
74063     } catch (...) {
74064       {
74065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74066       };
74067     }
74068   }
74069 }
74070
74071
74072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
74073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74074   unsigned int arg2 ;
74075
74076   arg1 = (Dali::Toolkit::TableView *)jarg1;
74077   arg2 = (unsigned int)jarg2;
74078   {
74079     try {
74080       (arg1)->DeleteRow(arg2);
74081     } catch (std::out_of_range& e) {
74082       {
74083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74084       };
74085     } catch (std::exception& e) {
74086       {
74087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74088       };
74089     } catch (...) {
74090       {
74091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74092       };
74093     }
74094   }
74095 }
74096
74097
74098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
74099   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74100   unsigned int arg2 ;
74101   std::vector< Dali::Actor > *arg3 = 0 ;
74102
74103   arg1 = (Dali::Toolkit::TableView *)jarg1;
74104   arg2 = (unsigned int)jarg2;
74105   arg3 = (std::vector< Dali::Actor > *)jarg3;
74106   if (!arg3) {
74107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74108     return ;
74109   }
74110   {
74111     try {
74112       (arg1)->DeleteRow(arg2,*arg3);
74113     } catch (std::out_of_range& e) {
74114       {
74115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74116       };
74117     } catch (std::exception& e) {
74118       {
74119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74120       };
74121     } catch (...) {
74122       {
74123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74124       };
74125     }
74126   }
74127 }
74128
74129
74130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
74131   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74132   unsigned int arg2 ;
74133
74134   arg1 = (Dali::Toolkit::TableView *)jarg1;
74135   arg2 = (unsigned int)jarg2;
74136   {
74137     try {
74138       (arg1)->InsertColumn(arg2);
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74146       };
74147     } catch (...) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74150       };
74151     }
74152   }
74153 }
74154
74155
74156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
74157   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74158   unsigned int arg2 ;
74159
74160   arg1 = (Dali::Toolkit::TableView *)jarg1;
74161   arg2 = (unsigned int)jarg2;
74162   {
74163     try {
74164       (arg1)->DeleteColumn(arg2);
74165     } catch (std::out_of_range& e) {
74166       {
74167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74168       };
74169     } catch (std::exception& e) {
74170       {
74171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74172       };
74173     } catch (...) {
74174       {
74175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74176       };
74177     }
74178   }
74179 }
74180
74181
74182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
74183   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74184   unsigned int arg2 ;
74185   std::vector< Dali::Actor > *arg3 = 0 ;
74186
74187   arg1 = (Dali::Toolkit::TableView *)jarg1;
74188   arg2 = (unsigned int)jarg2;
74189   arg3 = (std::vector< Dali::Actor > *)jarg3;
74190   if (!arg3) {
74191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74192     return ;
74193   }
74194   {
74195     try {
74196       (arg1)->DeleteColumn(arg2,*arg3);
74197     } catch (std::out_of_range& e) {
74198       {
74199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74200       };
74201     } catch (std::exception& e) {
74202       {
74203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74204       };
74205     } catch (...) {
74206       {
74207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74208       };
74209     }
74210   }
74211 }
74212
74213
74214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
74215   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74216   unsigned int arg2 ;
74217   unsigned int arg3 ;
74218
74219   arg1 = (Dali::Toolkit::TableView *)jarg1;
74220   arg2 = (unsigned int)jarg2;
74221   arg3 = (unsigned int)jarg3;
74222   {
74223     try {
74224       (arg1)->Resize(arg2,arg3);
74225     } catch (std::out_of_range& e) {
74226       {
74227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74228       };
74229     } catch (std::exception& e) {
74230       {
74231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74232       };
74233     } catch (...) {
74234       {
74235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74236       };
74237     }
74238   }
74239 }
74240
74241
74242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
74243   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74244   unsigned int arg2 ;
74245   unsigned int arg3 ;
74246   std::vector< Dali::Actor > *arg4 = 0 ;
74247
74248   arg1 = (Dali::Toolkit::TableView *)jarg1;
74249   arg2 = (unsigned int)jarg2;
74250   arg3 = (unsigned int)jarg3;
74251   arg4 = (std::vector< Dali::Actor > *)jarg4;
74252   if (!arg4) {
74253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74254     return ;
74255   }
74256   {
74257     try {
74258       (arg1)->Resize(arg2,arg3,*arg4);
74259     } catch (std::out_of_range& e) {
74260       {
74261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74262       };
74263     } catch (std::exception& e) {
74264       {
74265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74266       };
74267     } catch (...) {
74268       {
74269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74270       };
74271     }
74272   }
74273 }
74274
74275
74276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
74277   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74278   Dali::Size arg2 ;
74279   Dali::Size *argp2 ;
74280
74281   arg1 = (Dali::Toolkit::TableView *)jarg1;
74282   argp2 = (Dali::Size *)jarg2;
74283   if (!argp2) {
74284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
74285     return ;
74286   }
74287   arg2 = *argp2;
74288   {
74289     try {
74290       (arg1)->SetCellPadding(arg2);
74291     } catch (std::out_of_range& e) {
74292       {
74293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74294       };
74295     } catch (std::exception& e) {
74296       {
74297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74298       };
74299     } catch (...) {
74300       {
74301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74302       };
74303     }
74304   }
74305 }
74306
74307
74308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
74309   void * jresult ;
74310   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74311   Dali::Size result;
74312
74313   arg1 = (Dali::Toolkit::TableView *)jarg1;
74314   {
74315     try {
74316       result = (arg1)->GetCellPadding();
74317     } catch (std::out_of_range& e) {
74318       {
74319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74320       };
74321     } catch (std::exception& e) {
74322       {
74323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74324       };
74325     } catch (...) {
74326       {
74327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74328       };
74329     }
74330   }
74331   jresult = new Dali::Size((const Dali::Size &)result);
74332   return jresult;
74333 }
74334
74335
74336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
74337   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74338   unsigned int arg2 ;
74339
74340   arg1 = (Dali::Toolkit::TableView *)jarg1;
74341   arg2 = (unsigned int)jarg2;
74342   {
74343     try {
74344       (arg1)->SetFitHeight(arg2);
74345     } catch (std::out_of_range& e) {
74346       {
74347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74348       };
74349     } catch (std::exception& e) {
74350       {
74351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74356       };
74357     }
74358   }
74359 }
74360
74361
74362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
74363   unsigned int jresult ;
74364   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74365   unsigned int arg2 ;
74366   bool result;
74367
74368   arg1 = (Dali::Toolkit::TableView *)jarg1;
74369   arg2 = (unsigned int)jarg2;
74370   {
74371     try {
74372       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
74373     } catch (std::out_of_range& e) {
74374       {
74375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74376       };
74377     } catch (std::exception& e) {
74378       {
74379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74380       };
74381     } catch (...) {
74382       {
74383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74384       };
74385     }
74386   }
74387   jresult = result;
74388   return jresult;
74389 }
74390
74391
74392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
74393   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74394   unsigned int arg2 ;
74395
74396   arg1 = (Dali::Toolkit::TableView *)jarg1;
74397   arg2 = (unsigned int)jarg2;
74398   {
74399     try {
74400       (arg1)->SetFitWidth(arg2);
74401     } catch (std::out_of_range& e) {
74402       {
74403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74404       };
74405     } catch (std::exception& e) {
74406       {
74407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74408       };
74409     } catch (...) {
74410       {
74411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74412       };
74413     }
74414   }
74415 }
74416
74417
74418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
74419   unsigned int jresult ;
74420   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74421   unsigned int arg2 ;
74422   bool result;
74423
74424   arg1 = (Dali::Toolkit::TableView *)jarg1;
74425   arg2 = (unsigned int)jarg2;
74426   {
74427     try {
74428       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
74429     } catch (std::out_of_range& e) {
74430       {
74431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74432       };
74433     } catch (std::exception& e) {
74434       {
74435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74436       };
74437     } catch (...) {
74438       {
74439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74440       };
74441     }
74442   }
74443   jresult = result;
74444   return jresult;
74445 }
74446
74447
74448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
74449   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74450   unsigned int arg2 ;
74451   float arg3 ;
74452
74453   arg1 = (Dali::Toolkit::TableView *)jarg1;
74454   arg2 = (unsigned int)jarg2;
74455   arg3 = (float)jarg3;
74456   {
74457     try {
74458       (arg1)->SetFixedHeight(arg2,arg3);
74459     } catch (std::out_of_range& e) {
74460       {
74461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74462       };
74463     } catch (std::exception& e) {
74464       {
74465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74466       };
74467     } catch (...) {
74468       {
74469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74470       };
74471     }
74472   }
74473 }
74474
74475
74476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
74477   float jresult ;
74478   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74479   unsigned int arg2 ;
74480   float result;
74481
74482   arg1 = (Dali::Toolkit::TableView *)jarg1;
74483   arg2 = (unsigned int)jarg2;
74484   {
74485     try {
74486       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
74487     } catch (std::out_of_range& e) {
74488       {
74489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74490       };
74491     } catch (std::exception& e) {
74492       {
74493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74494       };
74495     } catch (...) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74498       };
74499     }
74500   }
74501   jresult = result;
74502   return jresult;
74503 }
74504
74505
74506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
74507   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74508   unsigned int arg2 ;
74509   float arg3 ;
74510
74511   arg1 = (Dali::Toolkit::TableView *)jarg1;
74512   arg2 = (unsigned int)jarg2;
74513   arg3 = (float)jarg3;
74514   {
74515     try {
74516       (arg1)->SetRelativeHeight(arg2,arg3);
74517     } catch (std::out_of_range& e) {
74518       {
74519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74520       };
74521     } catch (std::exception& e) {
74522       {
74523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74524       };
74525     } catch (...) {
74526       {
74527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74528       };
74529     }
74530   }
74531 }
74532
74533
74534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
74535   float jresult ;
74536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74537   unsigned int arg2 ;
74538   float result;
74539
74540   arg1 = (Dali::Toolkit::TableView *)jarg1;
74541   arg2 = (unsigned int)jarg2;
74542   {
74543     try {
74544       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
74545     } catch (std::out_of_range& e) {
74546       {
74547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74548       };
74549     } catch (std::exception& e) {
74550       {
74551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74552       };
74553     } catch (...) {
74554       {
74555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74556       };
74557     }
74558   }
74559   jresult = result;
74560   return jresult;
74561 }
74562
74563
74564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
74565   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74566   unsigned int arg2 ;
74567   float arg3 ;
74568
74569   arg1 = (Dali::Toolkit::TableView *)jarg1;
74570   arg2 = (unsigned int)jarg2;
74571   arg3 = (float)jarg3;
74572   {
74573     try {
74574       (arg1)->SetFixedWidth(arg2,arg3);
74575     } catch (std::out_of_range& e) {
74576       {
74577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74578       };
74579     } catch (std::exception& e) {
74580       {
74581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (...) {
74584       {
74585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74586       };
74587     }
74588   }
74589 }
74590
74591
74592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
74593   float jresult ;
74594   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74595   unsigned int arg2 ;
74596   float result;
74597
74598   arg1 = (Dali::Toolkit::TableView *)jarg1;
74599   arg2 = (unsigned int)jarg2;
74600   {
74601     try {
74602       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
74603     } catch (std::out_of_range& e) {
74604       {
74605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74606       };
74607     } catch (std::exception& e) {
74608       {
74609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74610       };
74611     } catch (...) {
74612       {
74613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74614       };
74615     }
74616   }
74617   jresult = result;
74618   return jresult;
74619 }
74620
74621
74622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
74623   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74624   unsigned int arg2 ;
74625   float arg3 ;
74626
74627   arg1 = (Dali::Toolkit::TableView *)jarg1;
74628   arg2 = (unsigned int)jarg2;
74629   arg3 = (float)jarg3;
74630   {
74631     try {
74632       (arg1)->SetRelativeWidth(arg2,arg3);
74633     } catch (std::out_of_range& e) {
74634       {
74635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (std::exception& e) {
74638       {
74639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74644       };
74645     }
74646   }
74647 }
74648
74649
74650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
74651   float jresult ;
74652   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74653   unsigned int arg2 ;
74654   float result;
74655
74656   arg1 = (Dali::Toolkit::TableView *)jarg1;
74657   arg2 = (unsigned int)jarg2;
74658   {
74659     try {
74660       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
74661     } catch (std::out_of_range& e) {
74662       {
74663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74664       };
74665     } catch (std::exception& e) {
74666       {
74667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74668       };
74669     } catch (...) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74672       };
74673     }
74674   }
74675   jresult = result;
74676   return jresult;
74677 }
74678
74679
74680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
74681   unsigned int jresult ;
74682   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74683   unsigned int result;
74684
74685   arg1 = (Dali::Toolkit::TableView *)jarg1;
74686   {
74687     try {
74688       result = (unsigned int)(arg1)->GetRows();
74689     } catch (std::out_of_range& e) {
74690       {
74691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74692       };
74693     } catch (std::exception& e) {
74694       {
74695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74696       };
74697     } catch (...) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74700       };
74701     }
74702   }
74703   jresult = result;
74704   return jresult;
74705 }
74706
74707
74708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
74709   unsigned int jresult ;
74710   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74711   unsigned int result;
74712
74713   arg1 = (Dali::Toolkit::TableView *)jarg1;
74714   {
74715     try {
74716       result = (unsigned int)(arg1)->GetColumns();
74717     } catch (std::out_of_range& e) {
74718       {
74719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74720       };
74721     } catch (std::exception& e) {
74722       {
74723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74724       };
74725     } catch (...) {
74726       {
74727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74728       };
74729     }
74730   }
74731   jresult = result;
74732   return jresult;
74733 }
74734
74735
74736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
74737   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74738   Dali::Toolkit::TableView::CellPosition arg2 ;
74739   Dali::HorizontalAlignment::Type arg3 ;
74740   Dali::VerticalAlignment::Type arg4 ;
74741   Dali::Toolkit::TableView::CellPosition *argp2 ;
74742
74743   arg1 = (Dali::Toolkit::TableView *)jarg1;
74744   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
74745   if (!argp2) {
74746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
74747     return ;
74748   }
74749   arg2 = *argp2;
74750   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
74751   arg4 = (Dali::VerticalAlignment::Type)jarg4;
74752   {
74753     try {
74754       (arg1)->SetCellAlignment(arg2,arg3,arg4);
74755     } catch (std::out_of_range& e) {
74756       {
74757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74758       };
74759     } catch (std::exception& e) {
74760       {
74761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74762       };
74763     } catch (...) {
74764       {
74765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74766       };
74767     }
74768   }
74769 }
74770
74771
74772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
74773   unsigned int jresult ;
74774   unsigned int result;
74775
74776   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
74777   jresult = result;
74778   return jresult;
74779 }
74780
74781
74782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
74783   int jresult ;
74784   int result;
74785
74786   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
74787   jresult = (int)result;
74788   return jresult;
74789 }
74790
74791
74792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
74793   int jresult ;
74794   int result;
74795
74796   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
74797   jresult = (int)result;
74798   return jresult;
74799 }
74800
74801
74802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
74803   int jresult ;
74804   int result;
74805
74806   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
74807   jresult = (int)result;
74808   return jresult;
74809 }
74810
74811
74812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
74813   int jresult ;
74814   int result;
74815
74816   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
74817   jresult = (int)result;
74818   return jresult;
74819 }
74820
74821
74822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
74823   int jresult ;
74824   int result;
74825
74826   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
74827   jresult = (int)result;
74828   return jresult;
74829 }
74830
74831
74832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
74833   int jresult ;
74834   int result;
74835
74836   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
74837   jresult = (int)result;
74838   return jresult;
74839 }
74840
74841
74842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
74843   int jresult ;
74844   int result;
74845
74846   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
74847   jresult = (int)result;
74848   return jresult;
74849 }
74850
74851
74852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
74853   int jresult ;
74854   int result;
74855
74856   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
74857   jresult = (int)result;
74858   return jresult;
74859 }
74860
74861
74862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
74863   int jresult ;
74864   int result;
74865
74866   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
74867   jresult = (int)result;
74868   return jresult;
74869 }
74870
74871
74872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
74873   int jresult ;
74874   int result;
74875
74876   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
74877   jresult = (int)result;
74878   return jresult;
74879 }
74880
74881
74882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
74883   int jresult ;
74884   int result;
74885
74886   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
74887   jresult = (int)result;
74888   return jresult;
74889 }
74890
74891
74892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
74893   int jresult ;
74894   int result;
74895
74896   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
74897   jresult = (int)result;
74898   return jresult;
74899 }
74900
74901
74902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
74903   int jresult ;
74904   int result;
74905
74906   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
74907   jresult = (int)result;
74908   return jresult;
74909 }
74910
74911
74912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
74913   int jresult ;
74914   int result;
74915
74916   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
74917   jresult = (int)result;
74918   return jresult;
74919 }
74920
74921
74922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
74923   int jresult ;
74924   int result;
74925
74926   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
74927   jresult = (int)result;
74928   return jresult;
74929 }
74930
74931
74932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
74933   int jresult ;
74934   int result;
74935
74936   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
74937   jresult = (int)result;
74938   return jresult;
74939 }
74940
74941
74942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
74943   int jresult ;
74944   int result;
74945
74946   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
74947   jresult = (int)result;
74948   return jresult;
74949 }
74950
74951
74952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
74953   int jresult ;
74954   int result;
74955
74956   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
74957   jresult = (int)result;
74958   return jresult;
74959 }
74960
74961
74962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
74963   int jresult ;
74964   int result;
74965
74966   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
74967   jresult = (int)result;
74968   return jresult;
74969 }
74970
74971
74972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
74973   int jresult ;
74974   int result;
74975
74976   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
74977   jresult = (int)result;
74978   return jresult;
74979 }
74980
74981
74982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
74983   int jresult ;
74984   int result;
74985
74986   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
74987   jresult = (int)result;
74988   return jresult;
74989 }
74990
74991
74992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
74993   int jresult ;
74994   int result;
74995
74996   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
74997   jresult = (int)result;
74998   return jresult;
74999 }
75000
75001
75002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
75003   int jresult ;
75004   int result;
75005
75006   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
75007   jresult = (int)result;
75008   return jresult;
75009 }
75010
75011
75012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
75013   int jresult ;
75014   int result;
75015
75016   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
75017   jresult = (int)result;
75018   return jresult;
75019 }
75020
75021
75022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
75023   void * jresult ;
75024   Dali::Toolkit::TextLabel::Property *result = 0 ;
75025
75026   {
75027     try {
75028       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
75029     } catch (std::out_of_range& e) {
75030       {
75031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75032       };
75033     } catch (std::exception& e) {
75034       {
75035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75036       };
75037     } catch (...) {
75038       {
75039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75040       };
75041     }
75042   }
75043   jresult = (void *)result;
75044   return jresult;
75045 }
75046
75047
75048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
75049   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
75050
75051   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
75052   {
75053     try {
75054       delete arg1;
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_TextLabel_New__SWIG_0() {
75073   void * jresult ;
75074   Dali::Toolkit::TextLabel result;
75075
75076   {
75077     try {
75078       result = Dali::Toolkit::TextLabel::New();
75079     } catch (std::out_of_range& e) {
75080       {
75081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75082       };
75083     } catch (std::exception& e) {
75084       {
75085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75086       };
75087     } catch (...) {
75088       {
75089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75090       };
75091     }
75092   }
75093   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75094   return jresult;
75095 }
75096
75097
75098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
75099   void * jresult ;
75100   std::string *arg1 = 0 ;
75101   Dali::Toolkit::TextLabel result;
75102
75103   if (!jarg1) {
75104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75105     return 0;
75106   }
75107   std::string arg1_str(jarg1);
75108   arg1 = &arg1_str;
75109   {
75110     try {
75111       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
75112     } catch (std::out_of_range& e) {
75113       {
75114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75115       };
75116     } catch (std::exception& e) {
75117       {
75118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75119       };
75120     } catch (...) {
75121       {
75122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75123       };
75124     }
75125   }
75126   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75127
75128   //argout typemap for const std::string&
75129
75130   return jresult;
75131 }
75132
75133
75134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
75135   void * jresult ;
75136   Dali::Toolkit::TextLabel *result = 0 ;
75137
75138   {
75139     try {
75140       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
75141     } catch (std::out_of_range& e) {
75142       {
75143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75144       };
75145     } catch (std::exception& e) {
75146       {
75147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75148       };
75149     } catch (...) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75152       };
75153     }
75154   }
75155   jresult = (void *)result;
75156   return jresult;
75157 }
75158
75159
75160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
75161   void * jresult ;
75162   Dali::Toolkit::TextLabel *arg1 = 0 ;
75163   Dali::Toolkit::TextLabel *result = 0 ;
75164
75165   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75166   if (!arg1) {
75167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
75168     return 0;
75169   }
75170   {
75171     try {
75172       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
75173     } catch (std::out_of_range& e) {
75174       {
75175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75176       };
75177     } catch (std::exception& e) {
75178       {
75179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75180       };
75181     } catch (...) {
75182       {
75183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75184       };
75185     }
75186   }
75187   jresult = (void *)result;
75188   return jresult;
75189 }
75190
75191
75192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
75193   void * jresult ;
75194   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
75195   Dali::Toolkit::TextLabel *arg2 = 0 ;
75196   Dali::Toolkit::TextLabel *result = 0 ;
75197
75198   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75199   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
75200   if (!arg2) {
75201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
75202     return 0;
75203   }
75204   {
75205     try {
75206       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
75207     } catch (std::out_of_range& e) {
75208       {
75209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75210       };
75211     } catch (std::exception& e) {
75212       {
75213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75214       };
75215     } catch (...) {
75216       {
75217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75218       };
75219     }
75220   }
75221   jresult = (void *)result;
75222   return jresult;
75223 }
75224
75225
75226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
75227   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
75228
75229   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75230   {
75231     try {
75232       delete arg1;
75233     } catch (std::out_of_range& e) {
75234       {
75235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75236       };
75237     } catch (std::exception& e) {
75238       {
75239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75240       };
75241     } catch (...) {
75242       {
75243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75244       };
75245     }
75246   }
75247 }
75248
75249
75250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
75251   void * jresult ;
75252   Dali::BaseHandle arg1 ;
75253   Dali::BaseHandle *argp1 ;
75254   Dali::Toolkit::TextLabel result;
75255
75256   argp1 = (Dali::BaseHandle *)jarg1;
75257   if (!argp1) {
75258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75259     return 0;
75260   }
75261   arg1 = *argp1;
75262   {
75263     try {
75264       result = Dali::Toolkit::TextLabel::DownCast(arg1);
75265     } catch (std::out_of_range& e) {
75266       {
75267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75268       };
75269     } catch (std::exception& e) {
75270       {
75271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75272       };
75273     } catch (...) {
75274       {
75275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75276       };
75277     }
75278   }
75279   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75280   return jresult;
75281 }
75282
75283
75284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
75285   void * jresult ;
75286   Dali::Toolkit::AccessibilityManager *result = 0 ;
75287
75288   {
75289     try {
75290       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
75291     } catch (std::out_of_range& e) {
75292       {
75293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (std::exception& e) {
75296       {
75297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75298       };
75299     } catch (...) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75302       };
75303     }
75304   }
75305   jresult = (void *)result;
75306   return jresult;
75307 }
75308
75309
75310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
75311   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75312
75313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75314   {
75315     try {
75316       delete arg1;
75317     } catch (std::out_of_range& e) {
75318       {
75319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75320       };
75321     } catch (std::exception& e) {
75322       {
75323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75324       };
75325     } catch (...) {
75326       {
75327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75328       };
75329     }
75330   }
75331 }
75332
75333
75334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
75335   void * jresult ;
75336   Dali::Toolkit::AccessibilityManager result;
75337
75338   {
75339     try {
75340       result = Dali::Toolkit::AccessibilityManager::Get();
75341     } catch (std::out_of_range& e) {
75342       {
75343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75344       };
75345     } catch (std::exception& e) {
75346       {
75347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75348       };
75349     } catch (...) {
75350       {
75351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75352       };
75353     }
75354   }
75355   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
75356   return jresult;
75357 }
75358
75359
75360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
75361   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75362   Dali::Actor arg2 ;
75363   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
75364   std::string *arg4 = 0 ;
75365   Dali::Actor *argp2 ;
75366
75367   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75368   argp2 = (Dali::Actor *)jarg2;
75369   if (!argp2) {
75370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75371     return ;
75372   }
75373   arg2 = *argp2;
75374   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
75375   if (!jarg4) {
75376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75377     return ;
75378   }
75379   std::string arg4_str(jarg4);
75380   arg4 = &arg4_str;
75381   {
75382     try {
75383       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
75384     } catch (std::out_of_range& e) {
75385       {
75386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75387       };
75388     } catch (std::exception& e) {
75389       {
75390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75391       };
75392     } catch (...) {
75393       {
75394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75395       };
75396     }
75397   }
75398
75399   //argout typemap for const std::string&
75400
75401 }
75402
75403
75404 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
75405   char * jresult ;
75406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75407   Dali::Actor arg2 ;
75408   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
75409   Dali::Actor *argp2 ;
75410   std::string result;
75411
75412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75413   argp2 = (Dali::Actor *)jarg2;
75414   if (!argp2) {
75415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75416     return 0;
75417   }
75418   arg2 = *argp2;
75419   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
75420   {
75421     try {
75422       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
75423     } catch (std::out_of_range& e) {
75424       {
75425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75426       };
75427     } catch (std::exception& e) {
75428       {
75429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75430       };
75431     } catch (...) {
75432       {
75433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75434       };
75435     }
75436   }
75437   jresult = SWIG_csharp_string_callback((&result)->c_str());
75438   return jresult;
75439 }
75440
75441
75442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
75443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75444   Dali::Actor arg2 ;
75445   unsigned int arg3 ;
75446   Dali::Actor *argp2 ;
75447
75448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75449   argp2 = (Dali::Actor *)jarg2;
75450   if (!argp2) {
75451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75452     return ;
75453   }
75454   arg2 = *argp2;
75455   arg3 = (unsigned int)jarg3;
75456   {
75457     try {
75458       (arg1)->SetFocusOrder(arg2,arg3);
75459     } catch (std::out_of_range& e) {
75460       {
75461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75462       };
75463     } catch (std::exception& e) {
75464       {
75465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75466       };
75467     } catch (...) {
75468       {
75469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75470       };
75471     }
75472   }
75473 }
75474
75475
75476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
75477   unsigned int jresult ;
75478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75479   Dali::Actor arg2 ;
75480   Dali::Actor *argp2 ;
75481   unsigned int result;
75482
75483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75484   argp2 = (Dali::Actor *)jarg2;
75485   if (!argp2) {
75486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75487     return 0;
75488   }
75489   arg2 = *argp2;
75490   {
75491     try {
75492       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
75493     } catch (std::out_of_range& e) {
75494       {
75495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75496       };
75497     } catch (std::exception& e) {
75498       {
75499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75500       };
75501     } catch (...) {
75502       {
75503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75504       };
75505     }
75506   }
75507   jresult = result;
75508   return jresult;
75509 }
75510
75511
75512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
75513   unsigned int jresult ;
75514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75515   unsigned int result;
75516
75517   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75518   {
75519     try {
75520       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
75521     } catch (std::out_of_range& e) {
75522       {
75523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75524       };
75525     } catch (std::exception& e) {
75526       {
75527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75528       };
75529     } catch (...) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75532       };
75533     }
75534   }
75535   jresult = result;
75536   return jresult;
75537 }
75538
75539
75540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
75541   void * jresult ;
75542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75543   unsigned int arg2 ;
75544   Dali::Actor result;
75545
75546   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75547   arg2 = (unsigned int)jarg2;
75548   {
75549     try {
75550       result = (arg1)->GetActorByFocusOrder(arg2);
75551     } catch (std::out_of_range& e) {
75552       {
75553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75554       };
75555     } catch (std::exception& e) {
75556       {
75557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75558       };
75559     } catch (...) {
75560       {
75561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75562       };
75563     }
75564   }
75565   jresult = new Dali::Actor((const Dali::Actor &)result);
75566   return jresult;
75567 }
75568
75569
75570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
75571   unsigned int jresult ;
75572   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75573   Dali::Actor arg2 ;
75574   Dali::Actor *argp2 ;
75575   bool result;
75576
75577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75578   argp2 = (Dali::Actor *)jarg2;
75579   if (!argp2) {
75580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75581     return 0;
75582   }
75583   arg2 = *argp2;
75584   {
75585     try {
75586       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
75587     } catch (std::out_of_range& e) {
75588       {
75589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75590       };
75591     } catch (std::exception& e) {
75592       {
75593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75594       };
75595     } catch (...) {
75596       {
75597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75598       };
75599     }
75600   }
75601   jresult = result;
75602   return jresult;
75603 }
75604
75605
75606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
75607   void * jresult ;
75608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75609   Dali::Actor result;
75610
75611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75612   {
75613     try {
75614       result = (arg1)->GetCurrentFocusActor();
75615     } catch (std::out_of_range& e) {
75616       {
75617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75618       };
75619     } catch (std::exception& e) {
75620       {
75621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75622       };
75623     } catch (...) {
75624       {
75625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75626       };
75627     }
75628   }
75629   jresult = new Dali::Actor((const Dali::Actor &)result);
75630   return jresult;
75631 }
75632
75633
75634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
75635   void * jresult ;
75636   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75637   Dali::Actor result;
75638
75639   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75640   {
75641     try {
75642       result = (arg1)->GetCurrentFocusGroup();
75643     } catch (std::out_of_range& e) {
75644       {
75645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75646       };
75647     } catch (std::exception& e) {
75648       {
75649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75650       };
75651     } catch (...) {
75652       {
75653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75654       };
75655     }
75656   }
75657   jresult = new Dali::Actor((const Dali::Actor &)result);
75658   return jresult;
75659 }
75660
75661
75662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
75663   unsigned int jresult ;
75664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75665   unsigned int result;
75666
75667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75668   {
75669     try {
75670       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
75671     } catch (std::out_of_range& e) {
75672       {
75673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75674       };
75675     } catch (std::exception& e) {
75676       {
75677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75678       };
75679     } catch (...) {
75680       {
75681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75682       };
75683     }
75684   }
75685   jresult = result;
75686   return jresult;
75687 }
75688
75689
75690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
75691   unsigned int jresult ;
75692   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75693   bool result;
75694
75695   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75696   {
75697     try {
75698       result = (bool)(arg1)->MoveFocusForward();
75699     } catch (std::out_of_range& e) {
75700       {
75701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75702       };
75703     } catch (std::exception& e) {
75704       {
75705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75706       };
75707     } catch (...) {
75708       {
75709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75710       };
75711     }
75712   }
75713   jresult = result;
75714   return jresult;
75715 }
75716
75717
75718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
75719   unsigned int jresult ;
75720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75721   bool result;
75722
75723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75724   {
75725     try {
75726       result = (bool)(arg1)->MoveFocusBackward();
75727     } catch (std::out_of_range& e) {
75728       {
75729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75730       };
75731     } catch (std::exception& e) {
75732       {
75733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75734       };
75735     } catch (...) {
75736       {
75737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75738       };
75739     }
75740   }
75741   jresult = result;
75742   return jresult;
75743 }
75744
75745
75746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
75747   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75748
75749   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75750   {
75751     try {
75752       (arg1)->ClearFocus();
75753     } catch (std::out_of_range& e) {
75754       {
75755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75756       };
75757     } catch (std::exception& e) {
75758       {
75759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75760       };
75761     } catch (...) {
75762       {
75763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75764       };
75765     }
75766   }
75767 }
75768
75769
75770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
75771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75772
75773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75774   {
75775     try {
75776       (arg1)->Reset();
75777     } catch (std::out_of_range& e) {
75778       {
75779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75780       };
75781     } catch (std::exception& e) {
75782       {
75783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75784       };
75785     } catch (...) {
75786       {
75787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75788       };
75789     }
75790   }
75791 }
75792
75793
75794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
75795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75796   Dali::Actor arg2 ;
75797   bool arg3 ;
75798   Dali::Actor *argp2 ;
75799
75800   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75801   argp2 = (Dali::Actor *)jarg2;
75802   if (!argp2) {
75803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75804     return ;
75805   }
75806   arg2 = *argp2;
75807   arg3 = jarg3 ? true : false;
75808   {
75809     try {
75810       (arg1)->SetFocusGroup(arg2,arg3);
75811     } catch (std::out_of_range& e) {
75812       {
75813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75814       };
75815     } catch (std::exception& e) {
75816       {
75817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75818       };
75819     } catch (...) {
75820       {
75821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75822       };
75823     }
75824   }
75825 }
75826
75827
75828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
75829   unsigned int jresult ;
75830   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75831   Dali::Actor arg2 ;
75832   Dali::Actor *argp2 ;
75833   bool result;
75834
75835   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75836   argp2 = (Dali::Actor *)jarg2;
75837   if (!argp2) {
75838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75839     return 0;
75840   }
75841   arg2 = *argp2;
75842   {
75843     try {
75844       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
75845     } catch (std::out_of_range& e) {
75846       {
75847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75848       };
75849     } catch (std::exception& e) {
75850       {
75851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75852       };
75853     } catch (...) {
75854       {
75855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75856       };
75857     }
75858   }
75859   jresult = result;
75860   return jresult;
75861 }
75862
75863
75864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
75865   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75866   bool arg2 ;
75867
75868   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75869   arg2 = jarg2 ? true : false;
75870   {
75871     try {
75872       (arg1)->SetGroupMode(arg2);
75873     } catch (std::out_of_range& e) {
75874       {
75875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75876       };
75877     } catch (std::exception& e) {
75878       {
75879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75880       };
75881     } catch (...) {
75882       {
75883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75884       };
75885     }
75886   }
75887 }
75888
75889
75890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
75891   unsigned int jresult ;
75892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75893   bool result;
75894
75895   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75896   {
75897     try {
75898       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
75899     } catch (std::out_of_range& e) {
75900       {
75901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75902       };
75903     } catch (std::exception& e) {
75904       {
75905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75906       };
75907     } catch (...) {
75908       {
75909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75910       };
75911     }
75912   }
75913   jresult = result;
75914   return jresult;
75915 }
75916
75917
75918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
75919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75920   bool arg2 ;
75921
75922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75923   arg2 = jarg2 ? true : false;
75924   {
75925     try {
75926       (arg1)->SetWrapMode(arg2);
75927     } catch (std::out_of_range& e) {
75928       {
75929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75930       };
75931     } catch (std::exception& e) {
75932       {
75933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75934       };
75935     } catch (...) {
75936       {
75937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75938       };
75939     }
75940   }
75941 }
75942
75943
75944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
75945   unsigned int jresult ;
75946   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75947   bool result;
75948
75949   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75950   {
75951     try {
75952       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
75953     } catch (std::out_of_range& e) {
75954       {
75955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75956       };
75957     } catch (std::exception& e) {
75958       {
75959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75960       };
75961     } catch (...) {
75962       {
75963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75964       };
75965     }
75966   }
75967   jresult = result;
75968   return jresult;
75969 }
75970
75971
75972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
75973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75974   Dali::Actor arg2 ;
75975   Dali::Actor *argp2 ;
75976
75977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75978   argp2 = (Dali::Actor *)jarg2;
75979   if (!argp2) {
75980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75981     return ;
75982   }
75983   arg2 = *argp2;
75984   {
75985     try {
75986       (arg1)->SetFocusIndicatorActor(arg2);
75987     } catch (std::out_of_range& e) {
75988       {
75989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75990       };
75991     } catch (std::exception& e) {
75992       {
75993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75994       };
75995     } catch (...) {
75996       {
75997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75998       };
75999     }
76000   }
76001 }
76002
76003
76004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
76005   void * jresult ;
76006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76007   Dali::Actor result;
76008
76009   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76010   {
76011     try {
76012       result = (arg1)->GetFocusIndicatorActor();
76013     } catch (std::out_of_range& e) {
76014       {
76015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76016       };
76017     } catch (std::exception& e) {
76018       {
76019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76020       };
76021     } catch (...) {
76022       {
76023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76024       };
76025     }
76026   }
76027   jresult = new Dali::Actor((const Dali::Actor &)result);
76028   return jresult;
76029 }
76030
76031
76032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
76033   void * jresult ;
76034   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76035   Dali::Actor arg2 ;
76036   Dali::Actor *argp2 ;
76037   Dali::Actor result;
76038
76039   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76040   argp2 = (Dali::Actor *)jarg2;
76041   if (!argp2) {
76042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76043     return 0;
76044   }
76045   arg2 = *argp2;
76046   {
76047     try {
76048       result = (arg1)->GetFocusGroup(arg2);
76049     } catch (std::out_of_range& e) {
76050       {
76051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76052       };
76053     } catch (std::exception& e) {
76054       {
76055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76056       };
76057     } catch (...) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76060       };
76061     }
76062   }
76063   jresult = new Dali::Actor((const Dali::Actor &)result);
76064   return jresult;
76065 }
76066
76067
76068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
76069   void * jresult ;
76070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76071   Dali::Vector2 result;
76072
76073   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76074   {
76075     try {
76076       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
76077     } catch (std::out_of_range& e) {
76078       {
76079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76080       };
76081     } catch (std::exception& e) {
76082       {
76083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76084       };
76085     } catch (...) {
76086       {
76087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76088       };
76089     }
76090   }
76091   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76092   return jresult;
76093 }
76094
76095
76096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
76097   void * jresult ;
76098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76099   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
76100
76101   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76102   {
76103     try {
76104       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
76105     } catch (std::out_of_range& e) {
76106       {
76107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76108       };
76109     } catch (std::exception& e) {
76110       {
76111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76112       };
76113     } catch (...) {
76114       {
76115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76116       };
76117     }
76118   }
76119   jresult = (void *)result;
76120   return jresult;
76121 }
76122
76123
76124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
76125   void * jresult ;
76126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76127   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
76128
76129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76130   {
76131     try {
76132       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
76133     } catch (std::out_of_range& e) {
76134       {
76135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76136       };
76137     } catch (std::exception& e) {
76138       {
76139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76140       };
76141     } catch (...) {
76142       {
76143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76144       };
76145     }
76146   }
76147   jresult = (void *)result;
76148   return jresult;
76149 }
76150
76151
76152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
76153   void * jresult ;
76154   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76155   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
76156
76157   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76158   {
76159     try {
76160       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76172       };
76173     }
76174   }
76175   jresult = (void *)result;
76176   return jresult;
76177 }
76178
76179
76180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
76181   void * jresult ;
76182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76183   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76184
76185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76186   {
76187     try {
76188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
76189     } catch (std::out_of_range& e) {
76190       {
76191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76192       };
76193     } catch (std::exception& e) {
76194       {
76195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76196       };
76197     } catch (...) {
76198       {
76199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76200       };
76201     }
76202   }
76203   jresult = (void *)result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
76209   void * jresult ;
76210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76211   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76212
76213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76214   {
76215     try {
76216       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
76217     } catch (std::out_of_range& e) {
76218       {
76219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76220       };
76221     } catch (std::exception& e) {
76222       {
76223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76224       };
76225     } catch (...) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76228       };
76229     }
76230   }
76231   jresult = (void *)result;
76232   return jresult;
76233 }
76234
76235
76236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
76237   void * jresult ;
76238   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76239   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76240
76241   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76242   {
76243     try {
76244       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
76245     } catch (std::out_of_range& e) {
76246       {
76247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76248       };
76249     } catch (std::exception& e) {
76250       {
76251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76252       };
76253     } catch (...) {
76254       {
76255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76256       };
76257     }
76258   }
76259   jresult = (void *)result;
76260   return jresult;
76261 }
76262
76263
76264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
76265   void * jresult ;
76266   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76267   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76268
76269   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76270   {
76271     try {
76272       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
76273     } catch (std::out_of_range& e) {
76274       {
76275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76276       };
76277     } catch (std::exception& e) {
76278       {
76279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76280       };
76281     } catch (...) {
76282       {
76283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76284       };
76285     }
76286   }
76287   jresult = (void *)result;
76288   return jresult;
76289 }
76290
76291
76292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
76293   void * jresult ;
76294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76295   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76296
76297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76298   {
76299     try {
76300       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
76301     } catch (std::out_of_range& e) {
76302       {
76303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76304       };
76305     } catch (std::exception& e) {
76306       {
76307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76308       };
76309     } catch (...) {
76310       {
76311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76312       };
76313     }
76314   }
76315   jresult = (void *)result;
76316   return jresult;
76317 }
76318
76319
76320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
76321   void * jresult ;
76322   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76323   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76324
76325   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76326   {
76327     try {
76328       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
76329     } catch (std::out_of_range& e) {
76330       {
76331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76332       };
76333     } catch (std::exception& e) {
76334       {
76335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76336       };
76337     } catch (...) {
76338       {
76339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76340       };
76341     }
76342   }
76343   jresult = (void *)result;
76344   return jresult;
76345 }
76346
76347
76348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
76349   void * jresult ;
76350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76351   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76352
76353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76354   {
76355     try {
76356       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
76357     } catch (std::out_of_range& e) {
76358       {
76359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76360       };
76361     } catch (std::exception& e) {
76362       {
76363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76364       };
76365     } catch (...) {
76366       {
76367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76368       };
76369     }
76370   }
76371   jresult = (void *)result;
76372   return jresult;
76373 }
76374
76375
76376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
76377   void * jresult ;
76378   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76379   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76380
76381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76382   {
76383     try {
76384       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
76385     } catch (std::out_of_range& e) {
76386       {
76387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76388       };
76389     } catch (std::exception& e) {
76390       {
76391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76392       };
76393     } catch (...) {
76394       {
76395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76396       };
76397     }
76398   }
76399   jresult = (void *)result;
76400   return jresult;
76401 }
76402
76403
76404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
76405   void * jresult ;
76406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76407   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76408
76409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76410   {
76411     try {
76412       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
76413     } catch (std::out_of_range& e) {
76414       {
76415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76416       };
76417     } catch (std::exception& e) {
76418       {
76419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76420       };
76421     } catch (...) {
76422       {
76423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76424       };
76425     }
76426   }
76427   jresult = (void *)result;
76428   return jresult;
76429 }
76430
76431
76432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
76433   void * jresult ;
76434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76435   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76436
76437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76438   {
76439     try {
76440       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
76441     } catch (std::out_of_range& e) {
76442       {
76443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76444       };
76445     } catch (std::exception& e) {
76446       {
76447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76448       };
76449     } catch (...) {
76450       {
76451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76452       };
76453     }
76454   }
76455   jresult = (void *)result;
76456   return jresult;
76457 }
76458
76459
76460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
76461   void * jresult ;
76462   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76463   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76464
76465   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76466   {
76467     try {
76468       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
76469     } catch (std::out_of_range& e) {
76470       {
76471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76472       };
76473     } catch (std::exception& e) {
76474       {
76475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76476       };
76477     } catch (...) {
76478       {
76479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76480       };
76481     }
76482   }
76483   jresult = (void *)result;
76484   return jresult;
76485 }
76486
76487
76488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
76489   void * jresult ;
76490   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76491   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76492
76493   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76494   {
76495     try {
76496       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
76497     } catch (std::out_of_range& e) {
76498       {
76499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76500       };
76501     } catch (std::exception& e) {
76502       {
76503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76504       };
76505     } catch (...) {
76506       {
76507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76508       };
76509     }
76510   }
76511   jresult = (void *)result;
76512   return jresult;
76513 }
76514
76515
76516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
76517   void * jresult ;
76518   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76519   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76520
76521   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76522   {
76523     try {
76524       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
76525     } catch (std::out_of_range& e) {
76526       {
76527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76528       };
76529     } catch (std::exception& e) {
76530       {
76531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76532       };
76533     } catch (...) {
76534       {
76535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76536       };
76537     }
76538   }
76539   jresult = (void *)result;
76540   return jresult;
76541 }
76542
76543
76544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
76545   void * jresult ;
76546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76547   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76548
76549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76550   {
76551     try {
76552       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
76553     } catch (std::out_of_range& e) {
76554       {
76555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76556       };
76557     } catch (std::exception& e) {
76558       {
76559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76560       };
76561     } catch (...) {
76562       {
76563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76564       };
76565     }
76566   }
76567   jresult = (void *)result;
76568   return jresult;
76569 }
76570
76571
76572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
76573   void * jresult ;
76574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76575   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76576
76577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76578   {
76579     try {
76580       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
76581     } catch (std::out_of_range& e) {
76582       {
76583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76584       };
76585     } catch (std::exception& e) {
76586       {
76587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76588       };
76589     } catch (...) {
76590       {
76591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76592       };
76593     }
76594   }
76595   jresult = (void *)result;
76596   return jresult;
76597 }
76598
76599
76600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
76601   void * jresult ;
76602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76603   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76604
76605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76606   {
76607     try {
76608       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
76609     } catch (std::out_of_range& e) {
76610       {
76611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76612       };
76613     } catch (std::exception& e) {
76614       {
76615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76616       };
76617     } catch (...) {
76618       {
76619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76620       };
76621     }
76622   }
76623   jresult = (void *)result;
76624   return jresult;
76625 }
76626
76627
76628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
76629   void * jresult ;
76630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76631   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76632
76633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76634   {
76635     try {
76636       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
76637     } catch (std::out_of_range& e) {
76638       {
76639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76640       };
76641     } catch (std::exception& e) {
76642       {
76643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76644       };
76645     } catch (...) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76648       };
76649     }
76650   }
76651   jresult = (void *)result;
76652   return jresult;
76653 }
76654
76655
76656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
76657   void * jresult ;
76658   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76659   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76660
76661   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76662   {
76663     try {
76664       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
76665     } catch (std::out_of_range& e) {
76666       {
76667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76668       };
76669     } catch (std::exception& e) {
76670       {
76671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76672       };
76673     } catch (...) {
76674       {
76675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76676       };
76677     }
76678   }
76679   jresult = (void *)result;
76680   return jresult;
76681 }
76682
76683
76684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
76685   void * jresult ;
76686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76687   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76688
76689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76690   {
76691     try {
76692       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
76693     } catch (std::out_of_range& e) {
76694       {
76695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (std::exception& e) {
76698       {
76699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76700       };
76701     } catch (...) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76704       };
76705     }
76706   }
76707   jresult = (void *)result;
76708   return jresult;
76709 }
76710
76711
76712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
76713   void * jresult ;
76714   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76715   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76716
76717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76718   {
76719     try {
76720       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
76721     } catch (std::out_of_range& e) {
76722       {
76723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76724       };
76725     } catch (std::exception& e) {
76726       {
76727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76728       };
76729     } catch (...) {
76730       {
76731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76732       };
76733     }
76734   }
76735   jresult = (void *)result;
76736   return jresult;
76737 }
76738
76739
76740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
76741   void * jresult ;
76742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76743   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76744
76745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76746   {
76747     try {
76748       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
76749     } catch (std::out_of_range& e) {
76750       {
76751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76752       };
76753     } catch (std::exception& e) {
76754       {
76755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76756       };
76757     } catch (...) {
76758       {
76759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76760       };
76761     }
76762   }
76763   jresult = (void *)result;
76764   return jresult;
76765 }
76766
76767
76768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
76769   void * jresult ;
76770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76771   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76772
76773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76774   {
76775     try {
76776       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
76777     } catch (std::out_of_range& e) {
76778       {
76779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76780       };
76781     } catch (std::exception& e) {
76782       {
76783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76784       };
76785     } catch (...) {
76786       {
76787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76788       };
76789     }
76790   }
76791   jresult = (void *)result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
76797   void * jresult ;
76798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76799   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76800
76801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76802   {
76803     try {
76804       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
76805     } catch (std::out_of_range& e) {
76806       {
76807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76808       };
76809     } catch (std::exception& e) {
76810       {
76811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76812       };
76813     } catch (...) {
76814       {
76815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76816       };
76817     }
76818   }
76819   jresult = (void *)result;
76820   return jresult;
76821 }
76822
76823
76824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
76825   void * jresult ;
76826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76827   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76828
76829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76830   {
76831     try {
76832       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
76833     } catch (std::out_of_range& e) {
76834       {
76835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76836       };
76837     } catch (std::exception& e) {
76838       {
76839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76840       };
76841     } catch (...) {
76842       {
76843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76844       };
76845     }
76846   }
76847   jresult = (void *)result;
76848   return jresult;
76849 }
76850
76851
76852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
76853   void * jresult ;
76854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76855   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76856
76857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76858   {
76859     try {
76860       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
76861     } catch (std::out_of_range& e) {
76862       {
76863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76864       };
76865     } catch (std::exception& e) {
76866       {
76867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76868       };
76869     } catch (...) {
76870       {
76871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76872       };
76873     }
76874   }
76875   jresult = (void *)result;
76876   return jresult;
76877 }
76878
76879
76880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
76881   void * jresult ;
76882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76883   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76884
76885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76886   {
76887     try {
76888       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
76889     } catch (std::out_of_range& e) {
76890       {
76891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76892       };
76893     } catch (std::exception& e) {
76894       {
76895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76896       };
76897     } catch (...) {
76898       {
76899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76900       };
76901     }
76902   }
76903   jresult = (void *)result;
76904   return jresult;
76905 }
76906
76907
76908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
76909   void * jresult ;
76910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76911   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
76912
76913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76914   {
76915     try {
76916       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76924       };
76925     } catch (...) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76928       };
76929     }
76930   }
76931   jresult = (void *)result;
76932   return jresult;
76933 }
76934
76935
76936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
76937   void * jresult ;
76938   Dali::Toolkit::StyleManager *result = 0 ;
76939
76940   {
76941     try {
76942       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
76943     } catch (std::out_of_range& e) {
76944       {
76945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76946       };
76947     } catch (std::exception& e) {
76948       {
76949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (...) {
76952       {
76953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76954       };
76955     }
76956   }
76957   jresult = (void *)result;
76958   return jresult;
76959 }
76960
76961
76962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
76963   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76964
76965   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76966   {
76967     try {
76968       delete arg1;
76969     } catch (std::out_of_range& e) {
76970       {
76971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76972       };
76973     } catch (std::exception& e) {
76974       {
76975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76976       };
76977     } catch (...) {
76978       {
76979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76980       };
76981     }
76982   }
76983 }
76984
76985
76986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
76987   void * jresult ;
76988   Dali::Toolkit::StyleManager result;
76989
76990   {
76991     try {
76992       result = Dali::Toolkit::StyleManager::Get();
76993     } catch (std::out_of_range& e) {
76994       {
76995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76996       };
76997     } catch (std::exception& e) {
76998       {
76999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77000       };
77001     } catch (...) {
77002       {
77003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77004       };
77005     }
77006   }
77007   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
77008   return jresult;
77009 }
77010
77011
77012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
77013   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77014   std::string *arg2 = 0 ;
77015
77016   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77017   if (!jarg2) {
77018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77019     return ;
77020   }
77021   std::string arg2_str(jarg2);
77022   arg2 = &arg2_str;
77023   {
77024     try {
77025       (arg1)->ApplyTheme((std::string const &)*arg2);
77026     } catch (std::out_of_range& e) {
77027       {
77028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77029       };
77030     } catch (std::exception& e) {
77031       {
77032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77033       };
77034     } catch (...) {
77035       {
77036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77037       };
77038     }
77039   }
77040
77041   //argout typemap for const std::string&
77042
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
77047   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77048
77049   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77050   {
77051     try {
77052       (arg1)->ApplyDefaultTheme();
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (...) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77064       };
77065     }
77066   }
77067 }
77068
77069
77070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
77071   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77072   std::string *arg2 = 0 ;
77073   Dali::Property::Value *arg3 = 0 ;
77074
77075   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77076   if (!jarg2) {
77077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77078     return ;
77079   }
77080   std::string arg2_str(jarg2);
77081   arg2 = &arg2_str;
77082   arg3 = (Dali::Property::Value *)jarg3;
77083   if (!arg3) {
77084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
77085     return ;
77086   }
77087   {
77088     try {
77089       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
77090     } catch (std::out_of_range& e) {
77091       {
77092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77093       };
77094     } catch (std::exception& e) {
77095       {
77096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77097       };
77098     } catch (...) {
77099       {
77100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77101       };
77102     }
77103   }
77104
77105   //argout typemap for const std::string&
77106
77107 }
77108
77109
77110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
77111   unsigned int jresult ;
77112   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77113   std::string *arg2 = 0 ;
77114   Dali::Property::Value *arg3 = 0 ;
77115   bool result;
77116
77117   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77118   if (!jarg2) {
77119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77120     return 0;
77121   }
77122   std::string arg2_str(jarg2);
77123   arg2 = &arg2_str;
77124   arg3 = (Dali::Property::Value *)jarg3;
77125   if (!arg3) {
77126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
77127     return 0;
77128   }
77129   {
77130     try {
77131       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
77132     } catch (std::out_of_range& e) {
77133       {
77134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77135       };
77136     } catch (std::exception& e) {
77137       {
77138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77139       };
77140     } catch (...) {
77141       {
77142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77143       };
77144     }
77145   }
77146   jresult = result;
77147
77148   //argout typemap for const std::string&
77149
77150   return jresult;
77151 }
77152
77153
77154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
77155   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77156   Dali::Toolkit::Control arg2 ;
77157   std::string *arg3 = 0 ;
77158   std::string *arg4 = 0 ;
77159   Dali::Toolkit::Control *argp2 ;
77160
77161   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77162   argp2 = (Dali::Toolkit::Control *)jarg2;
77163   if (!argp2) {
77164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
77165     return ;
77166   }
77167   arg2 = *argp2;
77168   if (!jarg3) {
77169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77170     return ;
77171   }
77172   std::string arg3_str(jarg3);
77173   arg3 = &arg3_str;
77174   if (!jarg4) {
77175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77176     return ;
77177   }
77178   std::string arg4_str(jarg4);
77179   arg4 = &arg4_str;
77180   {
77181     try {
77182       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
77183     } catch (std::out_of_range& e) {
77184       {
77185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77186       };
77187     } catch (std::exception& e) {
77188       {
77189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77190       };
77191     } catch (...) {
77192       {
77193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77194       };
77195     }
77196   }
77197
77198   //argout typemap for const std::string&
77199
77200
77201   //argout typemap for const std::string&
77202
77203 }
77204
77205
77206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
77207   void * jresult ;
77208   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77209   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
77210
77211   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77212   {
77213     try {
77214       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
77215     } catch (std::out_of_range& e) {
77216       {
77217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77218       };
77219     } catch (std::exception& e) {
77220       {
77221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77222       };
77223     } catch (...) {
77224       {
77225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77226       };
77227     }
77228   }
77229   jresult = (void *)result;
77230   return jresult;
77231 }
77232
77233
77234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
77235   int jresult ;
77236   int result;
77237
77238   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
77239   jresult = (int)result;
77240   return jresult;
77241 }
77242
77243
77244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
77245   int jresult ;
77246   int result;
77247
77248   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
77249   jresult = (int)result;
77250   return jresult;
77251 }
77252
77253
77254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
77255   int jresult ;
77256   int result;
77257
77258   result = (int)Dali::Toolkit::Slider::Property::VALUE;
77259   jresult = (int)result;
77260   return jresult;
77261 }
77262
77263
77264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
77265   int jresult ;
77266   int result;
77267
77268   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
77269   jresult = (int)result;
77270   return jresult;
77271 }
77272
77273
77274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
77275   int jresult ;
77276   int result;
77277
77278   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
77279   jresult = (int)result;
77280   return jresult;
77281 }
77282
77283
77284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
77285   int jresult ;
77286   int result;
77287
77288   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
77289   jresult = (int)result;
77290   return jresult;
77291 }
77292
77293
77294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
77295   int jresult ;
77296   int result;
77297
77298   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
77299   jresult = (int)result;
77300   return jresult;
77301 }
77302
77303
77304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
77305   int jresult ;
77306   int result;
77307
77308   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
77309   jresult = (int)result;
77310   return jresult;
77311 }
77312
77313
77314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
77315   int jresult ;
77316   int result;
77317
77318   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
77319   jresult = (int)result;
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
77325   int jresult ;
77326   int result;
77327
77328   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
77329   jresult = (int)result;
77330   return jresult;
77331 }
77332
77333
77334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
77335   int jresult ;
77336   int result;
77337
77338   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
77339   jresult = (int)result;
77340   return jresult;
77341 }
77342
77343
77344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
77345   int jresult ;
77346   int result;
77347
77348   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
77349   jresult = (int)result;
77350   return jresult;
77351 }
77352
77353
77354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
77355   int jresult ;
77356   int result;
77357
77358   result = (int)Dali::Toolkit::Slider::Property::MARKS;
77359   jresult = (int)result;
77360   return jresult;
77361 }
77362
77363
77364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
77365   int jresult ;
77366   int result;
77367
77368   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
77369   jresult = (int)result;
77370   return jresult;
77371 }
77372
77373
77374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
77375   int jresult ;
77376   int result;
77377
77378   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
77379   jresult = (int)result;
77380   return jresult;
77381 }
77382
77383
77384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
77385   void * jresult ;
77386   Dali::Toolkit::Slider::Property *result = 0 ;
77387
77388   {
77389     try {
77390       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
77391     } catch (std::out_of_range& e) {
77392       {
77393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77394       };
77395     } catch (std::exception& e) {
77396       {
77397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77398       };
77399     } catch (...) {
77400       {
77401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77402       };
77403     }
77404   }
77405   jresult = (void *)result;
77406   return jresult;
77407 }
77408
77409
77410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
77411   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
77412
77413   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
77414   {
77415     try {
77416       delete arg1;
77417     } catch (std::out_of_range& e) {
77418       {
77419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77420       };
77421     } catch (std::exception& e) {
77422       {
77423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77424       };
77425     } catch (...) {
77426       {
77427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77428       };
77429     }
77430   }
77431 }
77432
77433
77434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
77435   void * jresult ;
77436   Dali::Toolkit::Slider result;
77437
77438   {
77439     try {
77440       result = Dali::Toolkit::Slider::New();
77441     } catch (std::out_of_range& e) {
77442       {
77443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77444       };
77445     } catch (std::exception& e) {
77446       {
77447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77448       };
77449     } catch (...) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77452       };
77453     }
77454   }
77455   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77456   return jresult;
77457 }
77458
77459
77460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
77461   void * jresult ;
77462   Dali::Toolkit::Slider *result = 0 ;
77463
77464   {
77465     try {
77466       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
77467     } catch (std::out_of_range& e) {
77468       {
77469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77470       };
77471     } catch (std::exception& e) {
77472       {
77473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77474       };
77475     } catch (...) {
77476       {
77477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77478       };
77479     }
77480   }
77481   jresult = (void *)result;
77482   return jresult;
77483 }
77484
77485
77486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
77487   void * jresult ;
77488   Dali::Toolkit::Slider *arg1 = 0 ;
77489   Dali::Toolkit::Slider *result = 0 ;
77490
77491   arg1 = (Dali::Toolkit::Slider *)jarg1;
77492   if (!arg1) {
77493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77494     return 0;
77495   }
77496   {
77497     try {
77498       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
77499     } catch (std::out_of_range& e) {
77500       {
77501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77502       };
77503     } catch (std::exception& e) {
77504       {
77505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77506       };
77507     } catch (...) {
77508       {
77509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77510       };
77511     }
77512   }
77513   jresult = (void *)result;
77514   return jresult;
77515 }
77516
77517
77518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
77519   void * jresult ;
77520   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77521   Dali::Toolkit::Slider *arg2 = 0 ;
77522   Dali::Toolkit::Slider *result = 0 ;
77523
77524   arg1 = (Dali::Toolkit::Slider *)jarg1;
77525   arg2 = (Dali::Toolkit::Slider *)jarg2;
77526   if (!arg2) {
77527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77528     return 0;
77529   }
77530   {
77531     try {
77532       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
77533     } catch (std::out_of_range& e) {
77534       {
77535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77536       };
77537     } catch (std::exception& e) {
77538       {
77539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77540       };
77541     } catch (...) {
77542       {
77543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77544       };
77545     }
77546   }
77547   jresult = (void *)result;
77548   return jresult;
77549 }
77550
77551
77552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
77553   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77554
77555   arg1 = (Dali::Toolkit::Slider *)jarg1;
77556   {
77557     try {
77558       delete arg1;
77559     } catch (std::out_of_range& e) {
77560       {
77561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77562       };
77563     } catch (std::exception& e) {
77564       {
77565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77566       };
77567     } catch (...) {
77568       {
77569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77570       };
77571     }
77572   }
77573 }
77574
77575
77576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
77577   void * jresult ;
77578   Dali::BaseHandle arg1 ;
77579   Dali::BaseHandle *argp1 ;
77580   Dali::Toolkit::Slider result;
77581
77582   argp1 = (Dali::BaseHandle *)jarg1;
77583   if (!argp1) {
77584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77585     return 0;
77586   }
77587   arg1 = *argp1;
77588   {
77589     try {
77590       result = Dali::Toolkit::Slider::DownCast(arg1);
77591     } catch (std::out_of_range& e) {
77592       {
77593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77594       };
77595     } catch (std::exception& e) {
77596       {
77597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77598       };
77599     } catch (...) {
77600       {
77601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77602       };
77603     }
77604   }
77605   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77606   return jresult;
77607 }
77608
77609
77610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
77611   void * jresult ;
77612   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77613   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77614
77615   arg1 = (Dali::Toolkit::Slider *)jarg1;
77616   {
77617     try {
77618       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77619     } catch (std::out_of_range& e) {
77620       {
77621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77622       };
77623     } catch (std::exception& e) {
77624       {
77625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77626       };
77627     } catch (...) {
77628       {
77629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77630       };
77631     }
77632   }
77633   jresult = (void *)result;
77634   return jresult;
77635 }
77636
77637
77638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
77639   void * jresult ;
77640   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77641   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77642
77643   arg1 = (Dali::Toolkit::Slider *)jarg1;
77644   {
77645     try {
77646       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
77647     } catch (std::out_of_range& e) {
77648       {
77649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77650       };
77651     } catch (std::exception& e) {
77652       {
77653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77654       };
77655     } catch (...) {
77656       {
77657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77658       };
77659     }
77660   }
77661   jresult = (void *)result;
77662   return jresult;
77663 }
77664
77665
77666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
77667   void * jresult ;
77668   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77669   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
77670
77671   arg1 = (Dali::Toolkit::Slider *)jarg1;
77672   {
77673     try {
77674       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
77675     } catch (std::out_of_range& e) {
77676       {
77677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77678       };
77679     } catch (std::exception& e) {
77680       {
77681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77682       };
77683     } catch (...) {
77684       {
77685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77686       };
77687     }
77688   }
77689   jresult = (void *)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
77695   int jresult ;
77696   int result;
77697
77698   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
77699   jresult = (int)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
77705   int jresult ;
77706   int result;
77707
77708   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
77709   jresult = (int)result;
77710   return jresult;
77711 }
77712
77713
77714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
77715   int jresult ;
77716   int result;
77717
77718   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
77719   jresult = (int)result;
77720   return jresult;
77721 }
77722
77723
77724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
77725   int jresult ;
77726   int result;
77727
77728   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
77729   jresult = (int)result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
77735   void * jresult ;
77736   Dali::Toolkit::VideoView::Property *result = 0 ;
77737
77738   {
77739     try {
77740       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
77741     } catch (std::out_of_range& e) {
77742       {
77743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77744       };
77745     } catch (std::exception& e) {
77746       {
77747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77748       };
77749     } catch (...) {
77750       {
77751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77752       };
77753     }
77754   }
77755   jresult = (void *)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
77761   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
77762
77763   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
77764   {
77765     try {
77766       delete arg1;
77767     } catch (std::out_of_range& e) {
77768       {
77769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77770       };
77771     } catch (std::exception& e) {
77772       {
77773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77774       };
77775     } catch (...) {
77776       {
77777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77778       };
77779     }
77780   }
77781 }
77782
77783
77784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
77785   void * jresult ;
77786   Dali::Toolkit::VideoView result;
77787
77788   {
77789     try {
77790       result = Dali::Toolkit::VideoView::New();
77791     } catch (std::out_of_range& e) {
77792       {
77793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77794       };
77795     } catch (std::exception& e) {
77796       {
77797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77798       };
77799     } catch (...) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77802       };
77803     }
77804   }
77805   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77806   return jresult;
77807 }
77808
77809
77810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
77811   void * jresult ;
77812   std::string *arg1 = 0 ;
77813   Dali::Toolkit::VideoView result;
77814
77815   if (!jarg1) {
77816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77817     return 0;
77818   }
77819   std::string arg1_str(jarg1);
77820   arg1 = &arg1_str;
77821   {
77822     try {
77823       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
77824     } catch (std::out_of_range& e) {
77825       {
77826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77827       };
77828     } catch (std::exception& e) {
77829       {
77830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77831       };
77832     } catch (...) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77835       };
77836     }
77837   }
77838   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77839
77840   //argout typemap for const std::string&
77841
77842   return jresult;
77843 }
77844
77845
77846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
77847   void * jresult ;
77848   Dali::Toolkit::VideoView *result = 0 ;
77849
77850   {
77851     try {
77852       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
77853     } catch (std::out_of_range& e) {
77854       {
77855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77856       };
77857     } catch (std::exception& e) {
77858       {
77859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77860       };
77861     } catch (...) {
77862       {
77863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77864       };
77865     }
77866   }
77867   jresult = (void *)result;
77868   return jresult;
77869 }
77870
77871
77872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
77873   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77874
77875   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77876   {
77877     try {
77878       delete arg1;
77879     } catch (std::out_of_range& e) {
77880       {
77881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77882       };
77883     } catch (std::exception& e) {
77884       {
77885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77886       };
77887     } catch (...) {
77888       {
77889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77890       };
77891     }
77892   }
77893 }
77894
77895
77896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
77897   void * jresult ;
77898   Dali::Toolkit::VideoView *arg1 = 0 ;
77899   Dali::Toolkit::VideoView *result = 0 ;
77900
77901   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77902   if (!arg1) {
77903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77904     return 0;
77905   }
77906   {
77907     try {
77908       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
77909     } catch (std::out_of_range& e) {
77910       {
77911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77912       };
77913     } catch (std::exception& e) {
77914       {
77915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (...) {
77918       {
77919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77920       };
77921     }
77922   }
77923   jresult = (void *)result;
77924   return jresult;
77925 }
77926
77927
77928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
77929   void * jresult ;
77930   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77931   Dali::Toolkit::VideoView *arg2 = 0 ;
77932   Dali::Toolkit::VideoView *result = 0 ;
77933
77934   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77935   arg2 = (Dali::Toolkit::VideoView *)jarg2;
77936   if (!arg2) {
77937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77938     return 0;
77939   }
77940   {
77941     try {
77942       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
77943     } catch (std::out_of_range& e) {
77944       {
77945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77946       };
77947     } catch (std::exception& e) {
77948       {
77949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77950       };
77951     } catch (...) {
77952       {
77953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77954       };
77955     }
77956   }
77957   jresult = (void *)result;
77958   return jresult;
77959 }
77960
77961
77962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
77963   void * jresult ;
77964   Dali::BaseHandle arg1 ;
77965   Dali::BaseHandle *argp1 ;
77966   Dali::Toolkit::VideoView result;
77967
77968   argp1 = (Dali::BaseHandle *)jarg1;
77969   if (!argp1) {
77970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77971     return 0;
77972   }
77973   arg1 = *argp1;
77974   {
77975     try {
77976       result = Dali::Toolkit::VideoView::DownCast(arg1);
77977     } catch (std::out_of_range& e) {
77978       {
77979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77980       };
77981     } catch (std::exception& e) {
77982       {
77983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77984       };
77985     } catch (...) {
77986       {
77987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77988       };
77989     }
77990   }
77991   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77992   return jresult;
77993 }
77994
77995
77996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
77997   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77998
77999   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78000   {
78001     try {
78002       (arg1)->Play();
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78010       };
78011     } catch (...) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78014       };
78015     }
78016   }
78017 }
78018
78019
78020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
78021   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78022
78023   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78024   {
78025     try {
78026       (arg1)->Pause();
78027     } catch (std::out_of_range& e) {
78028       {
78029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78030       };
78031     } catch (std::exception& e) {
78032       {
78033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78034       };
78035     } catch (...) {
78036       {
78037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78038       };
78039     }
78040   }
78041 }
78042
78043
78044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
78045   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78046
78047   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78048   {
78049     try {
78050       (arg1)->Stop();
78051     } catch (std::out_of_range& e) {
78052       {
78053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78054       };
78055     } catch (std::exception& e) {
78056       {
78057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78058       };
78059     } catch (...) {
78060       {
78061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78062       };
78063     }
78064   }
78065 }
78066
78067
78068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
78069   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78070   int arg2 ;
78071
78072   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78073   arg2 = (int)jarg2;
78074   {
78075     try {
78076       (arg1)->Forward(arg2);
78077     } catch (std::out_of_range& e) {
78078       {
78079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78080       };
78081     } catch (std::exception& e) {
78082       {
78083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78084       };
78085     } catch (...) {
78086       {
78087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78088       };
78089     }
78090   }
78091 }
78092
78093
78094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
78095   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78096   int arg2 ;
78097
78098   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78099   arg2 = (int)jarg2;
78100   {
78101     try {
78102       (arg1)->Backward(arg2);
78103     } catch (std::out_of_range& e) {
78104       {
78105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78106       };
78107     } catch (std::exception& e) {
78108       {
78109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78110       };
78111     } catch (...) {
78112       {
78113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78114       };
78115     }
78116   }
78117 }
78118
78119
78120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
78121   void * jresult ;
78122   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78123   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
78124
78125   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78126   {
78127     try {
78128       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
78129     } catch (std::out_of_range& e) {
78130       {
78131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78132       };
78133     } catch (std::exception& e) {
78134       {
78135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78136       };
78137     } catch (...) {
78138       {
78139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78140       };
78141     }
78142   }
78143   jresult = (void *)result;
78144   return jresult;
78145 }
78146
78147
78148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
78149   int jresult ;
78150   int result;
78151
78152   result = (int)Dali::Toolkit::Popup::Property::TITLE;
78153   jresult = (int)result;
78154   return jresult;
78155 }
78156
78157
78158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
78159   int jresult ;
78160   int result;
78161
78162   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
78163   jresult = (int)result;
78164   return jresult;
78165 }
78166
78167
78168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
78169   int jresult ;
78170   int result;
78171
78172   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
78173   jresult = (int)result;
78174   return jresult;
78175 }
78176
78177
78178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
78179   int jresult ;
78180   int result;
78181
78182   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
78183   jresult = (int)result;
78184   return jresult;
78185 }
78186
78187
78188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
78189   int jresult ;
78190   int result;
78191
78192   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
78193   jresult = (int)result;
78194   return jresult;
78195 }
78196
78197
78198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
78199   int jresult ;
78200   int result;
78201
78202   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
78203   jresult = (int)result;
78204   return jresult;
78205 }
78206
78207
78208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
78209   int jresult ;
78210   int result;
78211
78212   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
78213   jresult = (int)result;
78214   return jresult;
78215 }
78216
78217
78218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
78219   int jresult ;
78220   int result;
78221
78222   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
78223   jresult = (int)result;
78224   return jresult;
78225 }
78226
78227
78228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
78229   int jresult ;
78230   int result;
78231
78232   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
78233   jresult = (int)result;
78234   return jresult;
78235 }
78236
78237
78238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
78239   int jresult ;
78240   int result;
78241
78242   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
78243   jresult = (int)result;
78244   return jresult;
78245 }
78246
78247
78248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
78249   int jresult ;
78250   int result;
78251
78252   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
78253   jresult = (int)result;
78254   return jresult;
78255 }
78256
78257
78258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
78259   int jresult ;
78260   int result;
78261
78262   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
78263   jresult = (int)result;
78264   return jresult;
78265 }
78266
78267
78268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
78269   int jresult ;
78270   int result;
78271
78272   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
78273   jresult = (int)result;
78274   return jresult;
78275 }
78276
78277
78278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
78279   int jresult ;
78280   int result;
78281
78282   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
78283   jresult = (int)result;
78284   return jresult;
78285 }
78286
78287
78288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
78289   int jresult ;
78290   int result;
78291
78292   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
78293   jresult = (int)result;
78294   return jresult;
78295 }
78296
78297
78298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
78299   int jresult ;
78300   int result;
78301
78302   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
78303   jresult = (int)result;
78304   return jresult;
78305 }
78306
78307
78308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
78309   int jresult ;
78310   int result;
78311
78312   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
78313   jresult = (int)result;
78314   return jresult;
78315 }
78316
78317
78318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
78319   int jresult ;
78320   int result;
78321
78322   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
78323   jresult = (int)result;
78324   return jresult;
78325 }
78326
78327
78328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
78329   int jresult ;
78330   int result;
78331
78332   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
78333   jresult = (int)result;
78334   return jresult;
78335 }
78336
78337
78338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
78339   int jresult ;
78340   int result;
78341
78342   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
78343   jresult = (int)result;
78344   return jresult;
78345 }
78346
78347
78348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
78349   int jresult ;
78350   int result;
78351
78352   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
78353   jresult = (int)result;
78354   return jresult;
78355 }
78356
78357
78358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
78359   void * jresult ;
78360   Dali::Toolkit::Popup::Property *result = 0 ;
78361
78362   {
78363     try {
78364       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
78365     } catch (std::out_of_range& e) {
78366       {
78367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78368       };
78369     } catch (std::exception& e) {
78370       {
78371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78372       };
78373     } catch (...) {
78374       {
78375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78376       };
78377     }
78378   }
78379   jresult = (void *)result;
78380   return jresult;
78381 }
78382
78383
78384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
78385   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
78386
78387   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
78388   {
78389     try {
78390       delete arg1;
78391     } catch (std::out_of_range& e) {
78392       {
78393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78394       };
78395     } catch (std::exception& e) {
78396       {
78397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78398       };
78399     } catch (...) {
78400       {
78401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78402       };
78403     }
78404   }
78405 }
78406
78407
78408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
78409   void * jresult ;
78410   Dali::Toolkit::Popup *result = 0 ;
78411
78412   {
78413     try {
78414       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
78415     } catch (std::out_of_range& e) {
78416       {
78417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78418       };
78419     } catch (std::exception& e) {
78420       {
78421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78422       };
78423     } catch (...) {
78424       {
78425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78426       };
78427     }
78428   }
78429   jresult = (void *)result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
78435   void * jresult ;
78436   Dali::Toolkit::Popup result;
78437
78438   {
78439     try {
78440       result = Dali::Toolkit::Popup::New();
78441     } catch (std::out_of_range& e) {
78442       {
78443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78444       };
78445     } catch (std::exception& e) {
78446       {
78447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78452       };
78453     }
78454   }
78455   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78456   return jresult;
78457 }
78458
78459
78460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
78461   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78462
78463   arg1 = (Dali::Toolkit::Popup *)jarg1;
78464   {
78465     try {
78466       delete arg1;
78467     } catch (std::out_of_range& e) {
78468       {
78469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78470       };
78471     } catch (std::exception& e) {
78472       {
78473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78474       };
78475     } catch (...) {
78476       {
78477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78478       };
78479     }
78480   }
78481 }
78482
78483
78484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
78485   void * jresult ;
78486   Dali::Toolkit::Popup *arg1 = 0 ;
78487   Dali::Toolkit::Popup *result = 0 ;
78488
78489   arg1 = (Dali::Toolkit::Popup *)jarg1;
78490   if (!arg1) {
78491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78492     return 0;
78493   }
78494   {
78495     try {
78496       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
78497     } catch (std::out_of_range& e) {
78498       {
78499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78500       };
78501     } catch (std::exception& e) {
78502       {
78503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78504       };
78505     } catch (...) {
78506       {
78507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78508       };
78509     }
78510   }
78511   jresult = (void *)result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
78517   void * jresult ;
78518   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78519   Dali::Toolkit::Popup *arg2 = 0 ;
78520   Dali::Toolkit::Popup *result = 0 ;
78521
78522   arg1 = (Dali::Toolkit::Popup *)jarg1;
78523   arg2 = (Dali::Toolkit::Popup *)jarg2;
78524   if (!arg2) {
78525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78526     return 0;
78527   }
78528   {
78529     try {
78530       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
78531     } catch (std::out_of_range& e) {
78532       {
78533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78534       };
78535     } catch (std::exception& e) {
78536       {
78537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78538       };
78539     } catch (...) {
78540       {
78541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78542       };
78543     }
78544   }
78545   jresult = (void *)result;
78546   return jresult;
78547 }
78548
78549
78550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
78551   void * jresult ;
78552   Dali::BaseHandle arg1 ;
78553   Dali::BaseHandle *argp1 ;
78554   Dali::Toolkit::Popup result;
78555
78556   argp1 = (Dali::BaseHandle *)jarg1;
78557   if (!argp1) {
78558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78559     return 0;
78560   }
78561   arg1 = *argp1;
78562   {
78563     try {
78564       result = Dali::Toolkit::Popup::DownCast(arg1);
78565     } catch (std::out_of_range& e) {
78566       {
78567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (std::exception& e) {
78570       {
78571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78572       };
78573     } catch (...) {
78574       {
78575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78576       };
78577     }
78578   }
78579   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78580   return jresult;
78581 }
78582
78583
78584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
78585   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78586   Dali::Actor arg2 ;
78587   Dali::Actor *argp2 ;
78588
78589   arg1 = (Dali::Toolkit::Popup *)jarg1;
78590   argp2 = (Dali::Actor *)jarg2;
78591   if (!argp2) {
78592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78593     return ;
78594   }
78595   arg2 = *argp2;
78596   {
78597     try {
78598       (arg1)->SetTitle(arg2);
78599     } catch (std::out_of_range& e) {
78600       {
78601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78602       };
78603     } catch (std::exception& e) {
78604       {
78605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78606       };
78607     } catch (...) {
78608       {
78609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78610       };
78611     }
78612   }
78613 }
78614
78615
78616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
78617   void * jresult ;
78618   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78619   Dali::Actor result;
78620
78621   arg1 = (Dali::Toolkit::Popup *)jarg1;
78622   {
78623     try {
78624       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
78625     } catch (std::out_of_range& e) {
78626       {
78627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78628       };
78629     } catch (std::exception& e) {
78630       {
78631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78632       };
78633     } catch (...) {
78634       {
78635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78636       };
78637     }
78638   }
78639   jresult = new Dali::Actor((const Dali::Actor &)result);
78640   return jresult;
78641 }
78642
78643
78644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
78645   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78646   Dali::Actor arg2 ;
78647   Dali::Actor *argp2 ;
78648
78649   arg1 = (Dali::Toolkit::Popup *)jarg1;
78650   argp2 = (Dali::Actor *)jarg2;
78651   if (!argp2) {
78652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78653     return ;
78654   }
78655   arg2 = *argp2;
78656   {
78657     try {
78658       (arg1)->SetContent(arg2);
78659     } catch (std::out_of_range& e) {
78660       {
78661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78662       };
78663     } catch (std::exception& e) {
78664       {
78665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78666       };
78667     } catch (...) {
78668       {
78669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78670       };
78671     }
78672   }
78673 }
78674
78675
78676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
78677   void * jresult ;
78678   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78679   Dali::Actor result;
78680
78681   arg1 = (Dali::Toolkit::Popup *)jarg1;
78682   {
78683     try {
78684       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
78685     } catch (std::out_of_range& e) {
78686       {
78687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78688       };
78689     } catch (std::exception& e) {
78690       {
78691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78692       };
78693     } catch (...) {
78694       {
78695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78696       };
78697     }
78698   }
78699   jresult = new Dali::Actor((const Dali::Actor &)result);
78700   return jresult;
78701 }
78702
78703
78704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
78705   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78706   Dali::Actor arg2 ;
78707   Dali::Actor *argp2 ;
78708
78709   arg1 = (Dali::Toolkit::Popup *)jarg1;
78710   argp2 = (Dali::Actor *)jarg2;
78711   if (!argp2) {
78712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78713     return ;
78714   }
78715   arg2 = *argp2;
78716   {
78717     try {
78718       (arg1)->SetFooter(arg2);
78719     } catch (std::out_of_range& e) {
78720       {
78721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78722       };
78723     } catch (std::exception& e) {
78724       {
78725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78726       };
78727     } catch (...) {
78728       {
78729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78730       };
78731     }
78732   }
78733 }
78734
78735
78736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
78737   void * jresult ;
78738   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78739   Dali::Actor result;
78740
78741   arg1 = (Dali::Toolkit::Popup *)jarg1;
78742   {
78743     try {
78744       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
78745     } catch (std::out_of_range& e) {
78746       {
78747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78748       };
78749     } catch (std::exception& e) {
78750       {
78751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (...) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78756       };
78757     }
78758   }
78759   jresult = new Dali::Actor((const Dali::Actor &)result);
78760   return jresult;
78761 }
78762
78763
78764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
78765   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78766   Dali::Toolkit::Popup::DisplayState arg2 ;
78767
78768   arg1 = (Dali::Toolkit::Popup *)jarg1;
78769   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
78770   {
78771     try {
78772       (arg1)->SetDisplayState(arg2);
78773     } catch (std::out_of_range& e) {
78774       {
78775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78776       };
78777     } catch (std::exception& e) {
78778       {
78779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78780       };
78781     } catch (...) {
78782       {
78783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78784       };
78785     }
78786   }
78787 }
78788
78789
78790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
78791   int jresult ;
78792   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78793   Dali::Toolkit::Popup::DisplayState result;
78794
78795   arg1 = (Dali::Toolkit::Popup *)jarg1;
78796   {
78797     try {
78798       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
78799     } catch (std::out_of_range& e) {
78800       {
78801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (std::exception& e) {
78804       {
78805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (...) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78810       };
78811     }
78812   }
78813   jresult = (int)result;
78814   return jresult;
78815 }
78816
78817
78818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
78819   void * jresult ;
78820   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78821   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
78822
78823   arg1 = (Dali::Toolkit::Popup *)jarg1;
78824   {
78825     try {
78826       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
78827     } catch (std::out_of_range& e) {
78828       {
78829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78830       };
78831     } catch (std::exception& e) {
78832       {
78833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78834       };
78835     } catch (...) {
78836       {
78837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78838       };
78839     }
78840   }
78841   jresult = (void *)result;
78842   return jresult;
78843 }
78844
78845
78846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
78847   void * jresult ;
78848   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78849   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78850
78851   arg1 = (Dali::Toolkit::Popup *)jarg1;
78852   {
78853     try {
78854       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
78855     } catch (std::out_of_range& e) {
78856       {
78857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78858       };
78859     } catch (std::exception& e) {
78860       {
78861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78862       };
78863     } catch (...) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78866       };
78867     }
78868   }
78869   jresult = (void *)result;
78870   return jresult;
78871 }
78872
78873
78874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
78875   void * jresult ;
78876   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78877   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78878
78879   arg1 = (Dali::Toolkit::Popup *)jarg1;
78880   {
78881     try {
78882       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
78883     } catch (std::out_of_range& e) {
78884       {
78885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78886       };
78887     } catch (std::exception& e) {
78888       {
78889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78890       };
78891     } catch (...) {
78892       {
78893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78894       };
78895     }
78896   }
78897   jresult = (void *)result;
78898   return jresult;
78899 }
78900
78901
78902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
78903   void * jresult ;
78904   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78905   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78906
78907   arg1 = (Dali::Toolkit::Popup *)jarg1;
78908   {
78909     try {
78910       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
78911     } catch (std::out_of_range& e) {
78912       {
78913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78914       };
78915     } catch (std::exception& e) {
78916       {
78917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78918       };
78919     } catch (...) {
78920       {
78921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78922       };
78923     }
78924   }
78925   jresult = (void *)result;
78926   return jresult;
78927 }
78928
78929
78930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
78931   void * jresult ;
78932   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78933   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78934
78935   arg1 = (Dali::Toolkit::Popup *)jarg1;
78936   {
78937     try {
78938       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
78939     } catch (std::out_of_range& e) {
78940       {
78941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78942       };
78943     } catch (std::exception& e) {
78944       {
78945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78946       };
78947     } catch (...) {
78948       {
78949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78950       };
78951     }
78952   }
78953   jresult = (void *)result;
78954   return jresult;
78955 }
78956
78957
78958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
78959   int jresult ;
78960   int result;
78961
78962   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
78963   jresult = (int)result;
78964   return jresult;
78965 }
78966
78967
78968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
78969   int jresult ;
78970   int result;
78971
78972   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
78973   jresult = (int)result;
78974   return jresult;
78975 }
78976
78977
78978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
78979   int jresult ;
78980   int result;
78981
78982   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
78983   jresult = (int)result;
78984   return jresult;
78985 }
78986
78987
78988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
78989   int jresult ;
78990   int result;
78991
78992   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
78993   jresult = (int)result;
78994   return jresult;
78995 }
78996
78997
78998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
78999   int jresult ;
79000   int result;
79001
79002   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
79003   jresult = (int)result;
79004   return jresult;
79005 }
79006
79007
79008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
79009   int jresult ;
79010   int result;
79011
79012   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
79013   jresult = (int)result;
79014   return jresult;
79015 }
79016
79017
79018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
79019   int jresult ;
79020   int result;
79021
79022   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
79023   jresult = (int)result;
79024   return jresult;
79025 }
79026
79027
79028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
79029   int jresult ;
79030   int result;
79031
79032   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
79033   jresult = (int)result;
79034   return jresult;
79035 }
79036
79037
79038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
79039   int jresult ;
79040   int result;
79041
79042   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
79043   jresult = (int)result;
79044   return jresult;
79045 }
79046
79047
79048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
79049   void * jresult ;
79050   Dali::Toolkit::ProgressBar::Property *result = 0 ;
79051
79052   {
79053     try {
79054       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
79055     } catch (std::out_of_range& e) {
79056       {
79057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79058       };
79059     } catch (std::exception& e) {
79060       {
79061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79062       };
79063     } catch (...) {
79064       {
79065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79066       };
79067     }
79068   }
79069   jresult = (void *)result;
79070   return jresult;
79071 }
79072
79073
79074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
79075   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
79076
79077   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
79078   {
79079     try {
79080       delete arg1;
79081     } catch (std::out_of_range& e) {
79082       {
79083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79084       };
79085     } catch (std::exception& e) {
79086       {
79087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79088       };
79089     } catch (...) {
79090       {
79091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79092       };
79093     }
79094   }
79095 }
79096
79097
79098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
79099   void * jresult ;
79100   Dali::Toolkit::ProgressBar result;
79101
79102   {
79103     try {
79104       result = Dali::Toolkit::ProgressBar::New();
79105     } catch (std::out_of_range& e) {
79106       {
79107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (std::exception& e) {
79110       {
79111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (...) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79116       };
79117     }
79118   }
79119   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
79120   return jresult;
79121 }
79122
79123
79124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
79125   void * jresult ;
79126   Dali::Toolkit::ProgressBar *result = 0 ;
79127
79128   {
79129     try {
79130       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
79131     } catch (std::out_of_range& e) {
79132       {
79133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79134       };
79135     } catch (std::exception& e) {
79136       {
79137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79138       };
79139     } catch (...) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79142       };
79143     }
79144   }
79145   jresult = (void *)result;
79146   return jresult;
79147 }
79148
79149
79150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
79151   void * jresult ;
79152   Dali::Toolkit::ProgressBar *arg1 = 0 ;
79153   Dali::Toolkit::ProgressBar *result = 0 ;
79154
79155   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79156   if (!arg1) {
79157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
79158     return 0;
79159   }
79160   {
79161     try {
79162       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
79163     } catch (std::out_of_range& e) {
79164       {
79165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (std::exception& e) {
79168       {
79169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79170       };
79171     } catch (...) {
79172       {
79173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79174       };
79175     }
79176   }
79177   jresult = (void *)result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
79183   void * jresult ;
79184   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79185   Dali::Toolkit::ProgressBar *arg2 = 0 ;
79186   Dali::Toolkit::ProgressBar *result = 0 ;
79187
79188   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79189   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
79190   if (!arg2) {
79191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
79192     return 0;
79193   }
79194   {
79195     try {
79196       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
79197     } catch (std::out_of_range& e) {
79198       {
79199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79200       };
79201     } catch (std::exception& e) {
79202       {
79203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79204       };
79205     } catch (...) {
79206       {
79207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79208       };
79209     }
79210   }
79211   jresult = (void *)result;
79212   return jresult;
79213 }
79214
79215
79216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
79217   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79218
79219   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79220   {
79221     try {
79222       delete arg1;
79223     } catch (std::out_of_range& e) {
79224       {
79225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79226       };
79227     } catch (std::exception& e) {
79228       {
79229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79230       };
79231     } catch (...) {
79232       {
79233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79234       };
79235     }
79236   }
79237 }
79238
79239
79240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
79241   void * jresult ;
79242   Dali::BaseHandle arg1 ;
79243   Dali::BaseHandle *argp1 ;
79244   Dali::Toolkit::ProgressBar result;
79245
79246   argp1 = (Dali::BaseHandle *)jarg1;
79247   if (!argp1) {
79248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79249     return 0;
79250   }
79251   arg1 = *argp1;
79252   {
79253     try {
79254       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
79255     } catch (std::out_of_range& e) {
79256       {
79257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (std::exception& e) {
79260       {
79261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79262       };
79263     } catch (...) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79266       };
79267     }
79268   }
79269   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
79270   return jresult;
79271 }
79272
79273
79274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
79275   void * jresult ;
79276   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79277   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
79278
79279   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79280   {
79281     try {
79282       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
79283     } catch (std::out_of_range& e) {
79284       {
79285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79286       };
79287     } catch (std::exception& e) {
79288       {
79289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79290       };
79291     } catch (...) {
79292       {
79293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79294       };
79295     }
79296   }
79297   jresult = (void *)result;
79298   return jresult;
79299 }
79300
79301
79302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
79303   void * jresult ;
79304   Dali::Toolkit::GaussianBlurView *result = 0 ;
79305
79306   {
79307     try {
79308       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
79309     } catch (std::out_of_range& e) {
79310       {
79311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79312       };
79313     } catch (std::exception& e) {
79314       {
79315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79316       };
79317     } catch (...) {
79318       {
79319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79320       };
79321     }
79322   }
79323   jresult = (void *)result;
79324   return jresult;
79325 }
79326
79327
79328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
79329   void * jresult ;
79330   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
79331   Dali::Toolkit::GaussianBlurView *result = 0 ;
79332
79333   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79334   if (!arg1) {
79335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
79336     return 0;
79337   }
79338   {
79339     try {
79340       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
79341     } catch (std::out_of_range& e) {
79342       {
79343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79344       };
79345     } catch (std::exception& e) {
79346       {
79347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79348       };
79349     } catch (...) {
79350       {
79351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79352       };
79353     }
79354   }
79355   jresult = (void *)result;
79356   return jresult;
79357 }
79358
79359
79360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
79361   void * jresult ;
79362   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79363   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
79364   Dali::Toolkit::GaussianBlurView *result = 0 ;
79365
79366   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79367   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
79368   if (!arg2) {
79369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
79370     return 0;
79371   }
79372   {
79373     try {
79374       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
79375     } catch (std::out_of_range& e) {
79376       {
79377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79378       };
79379     } catch (std::exception& e) {
79380       {
79381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79382       };
79383     } catch (...) {
79384       {
79385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79386       };
79387     }
79388   }
79389   jresult = (void *)result;
79390   return jresult;
79391 }
79392
79393
79394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
79395   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79396
79397   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79398   {
79399     try {
79400       delete arg1;
79401     } catch (std::out_of_range& e) {
79402       {
79403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79404       };
79405     } catch (std::exception& e) {
79406       {
79407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79408       };
79409     } catch (...) {
79410       {
79411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79412       };
79413     }
79414   }
79415 }
79416
79417
79418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
79419   void * jresult ;
79420   Dali::BaseHandle arg1 ;
79421   Dali::BaseHandle *argp1 ;
79422   Dali::Toolkit::GaussianBlurView result;
79423
79424   argp1 = (Dali::BaseHandle *)jarg1;
79425   if (!argp1) {
79426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79427     return 0;
79428   }
79429   arg1 = *argp1;
79430   {
79431     try {
79432       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
79433     } catch (std::out_of_range& e) {
79434       {
79435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79436       };
79437     } catch (std::exception& e) {
79438       {
79439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79440       };
79441     } catch (...) {
79442       {
79443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79444       };
79445     }
79446   }
79447   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79448   return jresult;
79449 }
79450
79451
79452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
79453   void * jresult ;
79454   Dali::Toolkit::GaussianBlurView result;
79455
79456   {
79457     try {
79458       result = Dali::Toolkit::GaussianBlurView::New();
79459     } catch (std::out_of_range& e) {
79460       {
79461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79462       };
79463     } catch (std::exception& e) {
79464       {
79465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79466       };
79467     } catch (...) {
79468       {
79469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79470       };
79471     }
79472   }
79473   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79474   return jresult;
79475 }
79476
79477
79478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
79479   void * jresult ;
79480   unsigned int arg1 ;
79481   float arg2 ;
79482   Dali::Pixel::Format arg3 ;
79483   float arg4 ;
79484   float arg5 ;
79485   bool arg6 ;
79486   Dali::Toolkit::GaussianBlurView result;
79487
79488   arg1 = (unsigned int)jarg1;
79489   arg2 = (float)jarg2;
79490   arg3 = (Dali::Pixel::Format)jarg3;
79491   arg4 = (float)jarg4;
79492   arg5 = (float)jarg5;
79493   arg6 = jarg6 ? true : false;
79494   {
79495     try {
79496       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
79497     } catch (std::out_of_range& e) {
79498       {
79499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79500       };
79501     } catch (std::exception& e) {
79502       {
79503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (...) {
79506       {
79507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79508       };
79509     }
79510   }
79511   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79512   return jresult;
79513 }
79514
79515
79516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
79517   void * jresult ;
79518   unsigned int arg1 ;
79519   float arg2 ;
79520   Dali::Pixel::Format arg3 ;
79521   float arg4 ;
79522   float arg5 ;
79523   Dali::Toolkit::GaussianBlurView result;
79524
79525   arg1 = (unsigned int)jarg1;
79526   arg2 = (float)jarg2;
79527   arg3 = (Dali::Pixel::Format)jarg3;
79528   arg4 = (float)jarg4;
79529   arg5 = (float)jarg5;
79530   {
79531     try {
79532       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
79533     } catch (std::out_of_range& e) {
79534       {
79535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79536       };
79537     } catch (std::exception& e) {
79538       {
79539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79540       };
79541     } catch (...) {
79542       {
79543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79544       };
79545     }
79546   }
79547   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79548   return jresult;
79549 }
79550
79551
79552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
79553   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79554   Dali::Actor arg2 ;
79555   Dali::Actor *argp2 ;
79556
79557   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79558   argp2 = (Dali::Actor *)jarg2;
79559   if (!argp2) {
79560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79561     return ;
79562   }
79563   arg2 = *argp2;
79564   {
79565     try {
79566       (arg1)->Add(arg2);
79567     } catch (std::out_of_range& e) {
79568       {
79569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79570       };
79571     } catch (std::exception& e) {
79572       {
79573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79574       };
79575     } catch (...) {
79576       {
79577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79578       };
79579     }
79580   }
79581 }
79582
79583
79584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
79585   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79586   Dali::Actor arg2 ;
79587   Dali::Actor *argp2 ;
79588
79589   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79590   argp2 = (Dali::Actor *)jarg2;
79591   if (!argp2) {
79592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79593     return ;
79594   }
79595   arg2 = *argp2;
79596   {
79597     try {
79598       (arg1)->Remove(arg2);
79599     } catch (std::out_of_range& e) {
79600       {
79601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79602       };
79603     } catch (std::exception& e) {
79604       {
79605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79606       };
79607     } catch (...) {
79608       {
79609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79610       };
79611     }
79612   }
79613 }
79614
79615
79616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
79617   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79618
79619   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79620   {
79621     try {
79622       (arg1)->Activate();
79623     } catch (std::out_of_range& e) {
79624       {
79625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79626       };
79627     } catch (std::exception& e) {
79628       {
79629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79630       };
79631     } catch (...) {
79632       {
79633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79634       };
79635     }
79636   }
79637 }
79638
79639
79640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
79641   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79642
79643   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79644   {
79645     try {
79646       (arg1)->ActivateOnce();
79647     } catch (std::out_of_range& e) {
79648       {
79649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79650       };
79651     } catch (std::exception& e) {
79652       {
79653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79654       };
79655     } catch (...) {
79656       {
79657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79658       };
79659     }
79660   }
79661 }
79662
79663
79664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
79665   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79666
79667   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79668   {
79669     try {
79670       (arg1)->Deactivate();
79671     } catch (std::out_of_range& e) {
79672       {
79673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79674       };
79675     } catch (std::exception& e) {
79676       {
79677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79678       };
79679     } catch (...) {
79680       {
79681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79682       };
79683     }
79684   }
79685 }
79686
79687
79688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
79689   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79690   Dali::Image arg2 ;
79691   Dali::FrameBufferImage arg3 ;
79692   Dali::Image *argp2 ;
79693   Dali::FrameBufferImage *argp3 ;
79694
79695   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79696   argp2 = (Dali::Image *)jarg2;
79697   if (!argp2) {
79698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
79699     return ;
79700   }
79701   arg2 = *argp2;
79702   argp3 = (Dali::FrameBufferImage *)jarg3;
79703   if (!argp3) {
79704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
79705     return ;
79706   }
79707   arg3 = *argp3;
79708   {
79709     try {
79710       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
79711     } catch (std::out_of_range& e) {
79712       {
79713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79714       };
79715     } catch (std::exception& e) {
79716       {
79717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79718       };
79719     } catch (...) {
79720       {
79721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79722       };
79723     }
79724   }
79725 }
79726
79727
79728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
79729   int jresult ;
79730   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79731   Dali::Property::Index result;
79732
79733   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79734   {
79735     try {
79736       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
79737     } catch (std::out_of_range& e) {
79738       {
79739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79740       };
79741     } catch (std::exception& e) {
79742       {
79743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79744       };
79745     } catch (...) {
79746       {
79747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79748       };
79749     }
79750   }
79751   jresult = result;
79752   return jresult;
79753 }
79754
79755
79756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
79757   void * jresult ;
79758   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79759   Dali::FrameBufferImage result;
79760
79761   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79762   {
79763     try {
79764       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
79765     } catch (std::out_of_range& e) {
79766       {
79767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79768       };
79769     } catch (std::exception& e) {
79770       {
79771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79772       };
79773     } catch (...) {
79774       {
79775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79776       };
79777     }
79778   }
79779   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
79780   return jresult;
79781 }
79782
79783
79784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
79785   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79786   Dali::Vector4 *arg2 = 0 ;
79787
79788   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79789   arg2 = (Dali::Vector4 *)jarg2;
79790   if (!arg2) {
79791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
79792     return ;
79793   }
79794   {
79795     try {
79796       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
79797     } catch (std::out_of_range& e) {
79798       {
79799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79800       };
79801     } catch (std::exception& e) {
79802       {
79803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79804       };
79805     } catch (...) {
79806       {
79807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79808       };
79809     }
79810   }
79811 }
79812
79813
79814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
79815   void * jresult ;
79816   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79817   Dali::Vector4 result;
79818
79819   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79820   {
79821     try {
79822       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
79823     } catch (std::out_of_range& e) {
79824       {
79825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79826       };
79827     } catch (std::exception& e) {
79828       {
79829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79830       };
79831     } catch (...) {
79832       {
79833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79834       };
79835     }
79836   }
79837   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
79838   return jresult;
79839 }
79840
79841
79842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
79843   void * jresult ;
79844   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79845   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
79846
79847   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79848   {
79849     try {
79850       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
79851     } catch (std::out_of_range& e) {
79852       {
79853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79854       };
79855     } catch (std::exception& e) {
79856       {
79857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79858       };
79859     } catch (...) {
79860       {
79861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79862       };
79863     }
79864   }
79865   jresult = (void *)result;
79866   return jresult;
79867 }
79868
79869
79870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
79871   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79872
79873   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79874   {
79875     try {
79876       delete arg1;
79877     } catch (std::out_of_range& e) {
79878       {
79879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79880       };
79881     } catch (std::exception& e) {
79882       {
79883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79884       };
79885     } catch (...) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79888       };
79889     }
79890   }
79891 }
79892
79893
79894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
79895   unsigned int jresult ;
79896   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79897   unsigned int result;
79898
79899   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79900   {
79901     try {
79902       result = (unsigned int)(arg1)->GetNumberOfPages();
79903     } catch (std::out_of_range& e) {
79904       {
79905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79906       };
79907     } catch (std::exception& e) {
79908       {
79909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79910       };
79911     } catch (...) {
79912       {
79913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79914       };
79915     }
79916   }
79917   jresult = result;
79918   return jresult;
79919 }
79920
79921
79922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
79923   void * jresult ;
79924   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79925   unsigned int arg2 ;
79926   Dali::Texture result;
79927
79928   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79929   arg2 = (unsigned int)jarg2;
79930   {
79931     try {
79932       result = (arg1)->NewPage(arg2);
79933     } catch (std::out_of_range& e) {
79934       {
79935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79936       };
79937     } catch (std::exception& e) {
79938       {
79939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79940       };
79941     } catch (...) {
79942       {
79943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79944       };
79945     }
79946   }
79947   jresult = new Dali::Texture((const Dali::Texture &)result);
79948   return jresult;
79949 }
79950
79951
79952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
79953   int jresult ;
79954   int result;
79955
79956   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
79957   jresult = (int)result;
79958   return jresult;
79959 }
79960
79961
79962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
79963   int jresult ;
79964   int result;
79965
79966   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
79967   jresult = (int)result;
79968   return jresult;
79969 }
79970
79971
79972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
79973   int jresult ;
79974   int result;
79975
79976   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
79977   jresult = (int)result;
79978   return jresult;
79979 }
79980
79981
79982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
79983   void * jresult ;
79984   Dali::Toolkit::PageTurnView::Property *result = 0 ;
79985
79986   {
79987     try {
79988       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
79989     } catch (std::out_of_range& e) {
79990       {
79991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79992       };
79993     } catch (std::exception& e) {
79994       {
79995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79996       };
79997     } catch (...) {
79998       {
79999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80000       };
80001     }
80002   }
80003   jresult = (void *)result;
80004   return jresult;
80005 }
80006
80007
80008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
80009   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
80010
80011   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
80012   {
80013     try {
80014       delete arg1;
80015     } catch (std::out_of_range& e) {
80016       {
80017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80018       };
80019     } catch (std::exception& e) {
80020       {
80021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80022       };
80023     } catch (...) {
80024       {
80025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80026       };
80027     }
80028   }
80029 }
80030
80031
80032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
80033   void * jresult ;
80034   Dali::Toolkit::PageTurnView *result = 0 ;
80035
80036   {
80037     try {
80038       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
80039     } catch (std::out_of_range& e) {
80040       {
80041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80042       };
80043     } catch (std::exception& e) {
80044       {
80045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80046       };
80047     } catch (...) {
80048       {
80049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80050       };
80051     }
80052   }
80053   jresult = (void *)result;
80054   return jresult;
80055 }
80056
80057
80058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
80059   void * jresult ;
80060   Dali::Toolkit::PageTurnView *arg1 = 0 ;
80061   Dali::Toolkit::PageTurnView *result = 0 ;
80062
80063   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80064   if (!arg1) {
80065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
80066     return 0;
80067   }
80068   {
80069     try {
80070       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
80071     } catch (std::out_of_range& e) {
80072       {
80073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (std::exception& e) {
80076       {
80077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (...) {
80080       {
80081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80082       };
80083     }
80084   }
80085   jresult = (void *)result;
80086   return jresult;
80087 }
80088
80089
80090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
80091   void * jresult ;
80092   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80093   Dali::Toolkit::PageTurnView *arg2 = 0 ;
80094   Dali::Toolkit::PageTurnView *result = 0 ;
80095
80096   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80097   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
80098   if (!arg2) {
80099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
80100     return 0;
80101   }
80102   {
80103     try {
80104       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
80105     } catch (std::out_of_range& e) {
80106       {
80107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80108       };
80109     } catch (std::exception& e) {
80110       {
80111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (...) {
80114       {
80115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80116       };
80117     }
80118   }
80119   jresult = (void *)result;
80120   return jresult;
80121 }
80122
80123
80124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
80125   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80126
80127   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80128   {
80129     try {
80130       delete arg1;
80131     } catch (std::out_of_range& e) {
80132       {
80133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (std::exception& e) {
80136       {
80137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80138       };
80139     } catch (...) {
80140       {
80141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80142       };
80143     }
80144   }
80145 }
80146
80147
80148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
80149   void * jresult ;
80150   Dali::BaseHandle arg1 ;
80151   Dali::BaseHandle *argp1 ;
80152   Dali::Toolkit::PageTurnView result;
80153
80154   argp1 = (Dali::BaseHandle *)jarg1;
80155   if (!argp1) {
80156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80157     return 0;
80158   }
80159   arg1 = *argp1;
80160   {
80161     try {
80162       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
80163     } catch (std::out_of_range& e) {
80164       {
80165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80166       };
80167     } catch (std::exception& e) {
80168       {
80169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80170       };
80171     } catch (...) {
80172       {
80173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80174       };
80175     }
80176   }
80177   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
80178   return jresult;
80179 }
80180
80181
80182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
80183   void * jresult ;
80184   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80185   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
80186
80187   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80188   {
80189     try {
80190       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
80191     } catch (std::out_of_range& e) {
80192       {
80193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80194       };
80195     } catch (std::exception& e) {
80196       {
80197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80198       };
80199     } catch (...) {
80200       {
80201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80202       };
80203     }
80204   }
80205   jresult = (void *)result;
80206   return jresult;
80207 }
80208
80209
80210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
80211   void * jresult ;
80212   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80213   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
80214
80215   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80216   {
80217     try {
80218       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
80219     } catch (std::out_of_range& e) {
80220       {
80221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80222       };
80223     } catch (std::exception& e) {
80224       {
80225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80226       };
80227     } catch (...) {
80228       {
80229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80230       };
80231     }
80232   }
80233   jresult = (void *)result;
80234   return jresult;
80235 }
80236
80237
80238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
80239   void * jresult ;
80240   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80241   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
80242
80243   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80244   {
80245     try {
80246       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
80247     } catch (std::out_of_range& e) {
80248       {
80249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80250       };
80251     } catch (std::exception& e) {
80252       {
80253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80254       };
80255     } catch (...) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80258       };
80259     }
80260   }
80261   jresult = (void *)result;
80262   return jresult;
80263 }
80264
80265
80266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
80267   void * jresult ;
80268   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80269   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
80270
80271   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80272   {
80273     try {
80274       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
80275     } catch (std::out_of_range& e) {
80276       {
80277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80278       };
80279     } catch (std::exception& e) {
80280       {
80281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80282       };
80283     } catch (...) {
80284       {
80285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80286       };
80287     }
80288   }
80289   jresult = (void *)result;
80290   return jresult;
80291 }
80292
80293
80294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
80295   void * jresult ;
80296   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80297
80298   {
80299     try {
80300       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
80301     } catch (std::out_of_range& e) {
80302       {
80303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80304       };
80305     } catch (std::exception& e) {
80306       {
80307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80308       };
80309     } catch (...) {
80310       {
80311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80312       };
80313     }
80314   }
80315   jresult = (void *)result;
80316   return jresult;
80317 }
80318
80319
80320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
80321   void * jresult ;
80322   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
80323   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80324
80325   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80326   if (!arg1) {
80327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
80328     return 0;
80329   }
80330   {
80331     try {
80332       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
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_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
80353   void * jresult ;
80354   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
80355   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
80356   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80357
80358   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80359   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
80360   if (!arg2) {
80361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
80362     return 0;
80363   }
80364   {
80365     try {
80366       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
80367     } catch (std::out_of_range& e) {
80368       {
80369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80370       };
80371     } catch (std::exception& e) {
80372       {
80373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80374       };
80375     } catch (...) {
80376       {
80377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80378       };
80379     }
80380   }
80381   jresult = (void *)result;
80382   return jresult;
80383 }
80384
80385
80386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
80387   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
80388
80389   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80390   {
80391     try {
80392       delete arg1;
80393     } catch (std::out_of_range& e) {
80394       {
80395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80396       };
80397     } catch (std::exception& e) {
80398       {
80399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80400       };
80401     } catch (...) {
80402       {
80403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80404       };
80405     }
80406   }
80407 }
80408
80409
80410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
80411   void * jresult ;
80412   Dali::Toolkit::PageFactory *arg1 = 0 ;
80413   Dali::Vector2 *arg2 = 0 ;
80414   Dali::Toolkit::PageTurnLandscapeView result;
80415
80416   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80417   if (!arg1) {
80418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80419     return 0;
80420   }
80421   arg2 = (Dali::Vector2 *)jarg2;
80422   if (!arg2) {
80423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80424     return 0;
80425   }
80426   {
80427     try {
80428       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
80429     } catch (std::out_of_range& e) {
80430       {
80431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80432       };
80433     } catch (std::exception& e) {
80434       {
80435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80436       };
80437     } catch (...) {
80438       {
80439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80440       };
80441     }
80442   }
80443   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
80444   return jresult;
80445 }
80446
80447
80448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
80449   void * jresult ;
80450   Dali::BaseHandle arg1 ;
80451   Dali::BaseHandle *argp1 ;
80452   Dali::Toolkit::PageTurnLandscapeView result;
80453
80454   argp1 = (Dali::BaseHandle *)jarg1;
80455   if (!argp1) {
80456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80457     return 0;
80458   }
80459   arg1 = *argp1;
80460   {
80461     try {
80462       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
80463     } catch (std::out_of_range& e) {
80464       {
80465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80466       };
80467     } catch (std::exception& e) {
80468       {
80469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (...) {
80472       {
80473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80474       };
80475     }
80476   }
80477   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
80478   return jresult;
80479 }
80480
80481
80482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
80483   void * jresult ;
80484   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80485
80486   {
80487     try {
80488       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
80489     } catch (std::out_of_range& e) {
80490       {
80491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80492       };
80493     } catch (std::exception& e) {
80494       {
80495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80496       };
80497     } catch (...) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80500       };
80501     }
80502   }
80503   jresult = (void *)result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
80509   void * jresult ;
80510   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
80511   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80512
80513   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80514   if (!arg1) {
80515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80516     return 0;
80517   }
80518   {
80519     try {
80520       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
80521     } catch (std::out_of_range& e) {
80522       {
80523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80524       };
80525     } catch (std::exception& e) {
80526       {
80527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80528       };
80529     } catch (...) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80532       };
80533     }
80534   }
80535   jresult = (void *)result;
80536   return jresult;
80537 }
80538
80539
80540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
80541   void * jresult ;
80542   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80543   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
80544   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80545
80546   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80547   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
80548   if (!arg2) {
80549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80550     return 0;
80551   }
80552   {
80553     try {
80554       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
80555     } catch (std::out_of_range& e) {
80556       {
80557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80558       };
80559     } catch (std::exception& e) {
80560       {
80561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80566       };
80567     }
80568   }
80569   jresult = (void *)result;
80570   return jresult;
80571 }
80572
80573
80574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
80575   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80576
80577   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80578   {
80579     try {
80580       delete arg1;
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80588       };
80589     } catch (...) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80592       };
80593     }
80594   }
80595 }
80596
80597
80598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
80599   void * jresult ;
80600   Dali::Toolkit::PageFactory *arg1 = 0 ;
80601   Dali::Vector2 *arg2 = 0 ;
80602   Dali::Toolkit::PageTurnPortraitView result;
80603
80604   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80605   if (!arg1) {
80606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80607     return 0;
80608   }
80609   arg2 = (Dali::Vector2 *)jarg2;
80610   if (!arg2) {
80611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80612     return 0;
80613   }
80614   {
80615     try {
80616       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
80617     } catch (std::out_of_range& e) {
80618       {
80619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80620       };
80621     } catch (std::exception& e) {
80622       {
80623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80624       };
80625     } catch (...) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80628       };
80629     }
80630   }
80631   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
80637   void * jresult ;
80638   Dali::BaseHandle arg1 ;
80639   Dali::BaseHandle *argp1 ;
80640   Dali::Toolkit::PageTurnPortraitView result;
80641
80642   argp1 = (Dali::BaseHandle *)jarg1;
80643   if (!argp1) {
80644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80645     return 0;
80646   }
80647   arg1 = *argp1;
80648   {
80649     try {
80650       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
80651     } catch (std::out_of_range& e) {
80652       {
80653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80654       };
80655     } catch (std::exception& e) {
80656       {
80657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80658       };
80659     } catch (...) {
80660       {
80661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80662       };
80663     }
80664   }
80665   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80666   return jresult;
80667 }
80668
80669
80670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
80671   int jresult ;
80672   int result;
80673
80674   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
80675   jresult = (int)result;
80676   return jresult;
80677 }
80678
80679
80680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
80681   int jresult ;
80682   int result;
80683
80684   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
80685   jresult = (int)result;
80686   return jresult;
80687 }
80688
80689
80690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
80691   int jresult ;
80692   int result;
80693
80694   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
80695   jresult = (int)result;
80696   return jresult;
80697 }
80698
80699
80700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
80701   void * jresult ;
80702   Dali::Toolkit::ToggleButton::Property *result = 0 ;
80703
80704   {
80705     try {
80706       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
80707     } catch (std::out_of_range& e) {
80708       {
80709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80710       };
80711     } catch (std::exception& e) {
80712       {
80713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80714       };
80715     } catch (...) {
80716       {
80717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80718       };
80719     }
80720   }
80721   jresult = (void *)result;
80722   return jresult;
80723 }
80724
80725
80726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
80727   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
80728
80729   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
80730   {
80731     try {
80732       delete arg1;
80733     } catch (std::out_of_range& e) {
80734       {
80735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80736       };
80737     } catch (std::exception& e) {
80738       {
80739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80740       };
80741     } catch (...) {
80742       {
80743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80744       };
80745     }
80746   }
80747 }
80748
80749
80750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
80751   void * jresult ;
80752   Dali::Toolkit::ToggleButton *result = 0 ;
80753
80754   {
80755     try {
80756       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
80757     } catch (std::out_of_range& e) {
80758       {
80759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80760       };
80761     } catch (std::exception& e) {
80762       {
80763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80764       };
80765     } catch (...) {
80766       {
80767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80768       };
80769     }
80770   }
80771   jresult = (void *)result;
80772   return jresult;
80773 }
80774
80775
80776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
80777   void * jresult ;
80778   Dali::Toolkit::ToggleButton *arg1 = 0 ;
80779   Dali::Toolkit::ToggleButton *result = 0 ;
80780
80781   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80782   if (!arg1) {
80783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
80784     return 0;
80785   }
80786   {
80787     try {
80788       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
80789     } catch (std::out_of_range& e) {
80790       {
80791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80792       };
80793     } catch (std::exception& e) {
80794       {
80795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80796       };
80797     } catch (...) {
80798       {
80799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80800       };
80801     }
80802   }
80803   jresult = (void *)result;
80804   return jresult;
80805 }
80806
80807
80808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
80809   void * jresult ;
80810   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
80811   Dali::Toolkit::ToggleButton *arg2 = 0 ;
80812   Dali::Toolkit::ToggleButton *result = 0 ;
80813
80814   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80815   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
80816   if (!arg2) {
80817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
80818     return 0;
80819   }
80820   {
80821     try {
80822       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
80823     } catch (std::out_of_range& e) {
80824       {
80825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80826       };
80827     } catch (std::exception& e) {
80828       {
80829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80830       };
80831     } catch (...) {
80832       {
80833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80834       };
80835     }
80836   }
80837   jresult = (void *)result;
80838   return jresult;
80839 }
80840
80841
80842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
80843   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
80844
80845   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80846   {
80847     try {
80848       delete arg1;
80849     } catch (std::out_of_range& e) {
80850       {
80851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80852       };
80853     } catch (std::exception& e) {
80854       {
80855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80856       };
80857     } catch (...) {
80858       {
80859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80860       };
80861     }
80862   }
80863 }
80864
80865
80866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
80867   void * jresult ;
80868   Dali::Toolkit::ToggleButton result;
80869
80870   {
80871     try {
80872       result = Dali::Toolkit::ToggleButton::New();
80873     } catch (std::out_of_range& e) {
80874       {
80875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80876       };
80877     } catch (std::exception& e) {
80878       {
80879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80880       };
80881     } catch (...) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80884       };
80885     }
80886   }
80887   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
80888   return jresult;
80889 }
80890
80891
80892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
80893   void * jresult ;
80894   Dali::BaseHandle arg1 ;
80895   Dali::BaseHandle *argp1 ;
80896   Dali::Toolkit::ToggleButton result;
80897
80898   argp1 = (Dali::BaseHandle *)jarg1;
80899   if (!argp1) {
80900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80901     return 0;
80902   }
80903   arg1 = *argp1;
80904   {
80905     try {
80906       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
80907     } catch (std::out_of_range& e) {
80908       {
80909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80910       };
80911     } catch (std::exception& e) {
80912       {
80913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80914       };
80915     } catch (...) {
80916       {
80917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80918       };
80919     }
80920   }
80921   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
80922   return jresult;
80923 }
80924
80925
80926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
80927   void * jresult ;
80928   Dali::Toolkit::Visual::Base *result = 0 ;
80929
80930   {
80931     try {
80932       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
80933     } catch (std::out_of_range& e) {
80934       {
80935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80936       };
80937     } catch (std::exception& e) {
80938       {
80939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80940       };
80941     } catch (...) {
80942       {
80943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80944       };
80945     }
80946   }
80947   jresult = (void *)result;
80948   return jresult;
80949 }
80950
80951
80952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
80953   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80954
80955   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80956   {
80957     try {
80958       delete arg1;
80959     } catch (std::out_of_range& e) {
80960       {
80961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80962       };
80963     } catch (std::exception& e) {
80964       {
80965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80966       };
80967     } catch (...) {
80968       {
80969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80970       };
80971     }
80972   }
80973 }
80974
80975
80976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
80977   void * jresult ;
80978   Dali::Toolkit::Visual::Base *arg1 = 0 ;
80979   Dali::Toolkit::Visual::Base *result = 0 ;
80980
80981   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80982   if (!arg1) {
80983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
80984     return 0;
80985   }
80986   {
80987     try {
80988       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
80989     } catch (std::out_of_range& e) {
80990       {
80991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80992       };
80993     } catch (std::exception& e) {
80994       {
80995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80996       };
80997     } catch (...) {
80998       {
80999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81000       };
81001     }
81002   }
81003   jresult = (void *)result;
81004   return jresult;
81005 }
81006
81007
81008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
81009   void * jresult ;
81010   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81011   Dali::Toolkit::Visual::Base *arg2 = 0 ;
81012   Dali::Toolkit::Visual::Base *result = 0 ;
81013
81014   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81015   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
81016   if (!arg2) {
81017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
81018     return 0;
81019   }
81020   {
81021     try {
81022       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
81023     } catch (std::out_of_range& e) {
81024       {
81025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81026       };
81027     } catch (std::exception& e) {
81028       {
81029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81030       };
81031     } catch (...) {
81032       {
81033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81034       };
81035     }
81036   }
81037   jresult = (void *)result;
81038   return jresult;
81039 }
81040
81041
81042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
81043   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81044   std::string *arg2 = 0 ;
81045
81046   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81047   if (!jarg2) {
81048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81049     return ;
81050   }
81051   std::string arg2_str(jarg2);
81052   arg2 = &arg2_str;
81053   {
81054     try {
81055       (arg1)->SetName((std::string const &)*arg2);
81056     } catch (std::out_of_range& e) {
81057       {
81058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81059       };
81060     } catch (std::exception& e) {
81061       {
81062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81063       };
81064     } catch (...) {
81065       {
81066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81067       };
81068     }
81069   }
81070
81071   //argout typemap for const std::string&
81072
81073 }
81074
81075
81076 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
81077   char * jresult ;
81078   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81079   std::string *result = 0 ;
81080
81081   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81082   {
81083     try {
81084       result = (std::string *) &(arg1)->GetName();
81085     } catch (std::out_of_range& e) {
81086       {
81087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81088       };
81089     } catch (std::exception& e) {
81090       {
81091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81096       };
81097     }
81098   }
81099   jresult = SWIG_csharp_string_callback(result->c_str());
81100   return jresult;
81101 }
81102
81103
81104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
81105   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81106   Dali::Property::Map *arg2 = 0 ;
81107   Dali::Size arg3 ;
81108   Dali::Size *argp3 ;
81109
81110   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81111   arg2 = (Dali::Property::Map *)jarg2;
81112   if (!arg2) {
81113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
81114     return ;
81115   }
81116   argp3 = (Dali::Size *)jarg3;
81117   if (!argp3) {
81118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
81119     return ;
81120   }
81121   arg3 = *argp3;
81122   {
81123     try {
81124       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
81125     } catch (std::out_of_range& e) {
81126       {
81127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81128       };
81129     } catch (std::exception& e) {
81130       {
81131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81132       };
81133     } catch (...) {
81134       {
81135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81136       };
81137     }
81138   }
81139 }
81140
81141
81142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
81143   float jresult ;
81144   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81145   float arg2 ;
81146   float result;
81147
81148   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81149   arg2 = (float)jarg2;
81150   {
81151     try {
81152       result = (float)(arg1)->GetHeightForWidth(arg2);
81153     } catch (std::out_of_range& e) {
81154       {
81155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (std::exception& e) {
81158       {
81159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81164       };
81165     }
81166   }
81167   jresult = result;
81168   return jresult;
81169 }
81170
81171
81172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
81173   float jresult ;
81174   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81175   float arg2 ;
81176   float result;
81177
81178   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81179   arg2 = (float)jarg2;
81180   {
81181     try {
81182       result = (float)(arg1)->GetWidthForHeight(arg2);
81183     } catch (std::out_of_range& e) {
81184       {
81185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81186       };
81187     } catch (std::exception& e) {
81188       {
81189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81190       };
81191     } catch (...) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81194       };
81195     }
81196   }
81197   jresult = result;
81198   return jresult;
81199 }
81200
81201
81202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
81203   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81204   Dali::Vector2 *arg2 = 0 ;
81205
81206   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81207   arg2 = (Dali::Vector2 *)jarg2;
81208   if (!arg2) {
81209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
81210     return ;
81211   }
81212   {
81213     try {
81214       (arg1)->GetNaturalSize(*arg2);
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81222       };
81223     } catch (...) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81226       };
81227     }
81228   }
81229 }
81230
81231
81232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
81233   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81234   float arg2 ;
81235
81236   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81237   arg2 = (int)jarg2;
81238   {
81239     try {
81240       (arg1)->SetDepthIndex(arg2);
81241     } catch (std::out_of_range& e) {
81242       {
81243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81244       };
81245     } catch (std::exception& e) {
81246       {
81247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81248       };
81249     } catch (...) {
81250       {
81251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81252       };
81253     }
81254   }
81255 }
81256
81257
81258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
81259   int jresult ;
81260   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81261   int result;
81262
81263   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81264   {
81265     try {
81266       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
81267     } catch (std::out_of_range& e) {
81268       {
81269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81270       };
81271     } catch (std::exception& e) {
81272       {
81273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81274       };
81275     } catch (...) {
81276       {
81277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81278       };
81279     }
81280   }
81281   jresult = result;
81282   return jresult;
81283 }
81284
81285
81286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
81287   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81288   Dali::Property::Map *arg2 = 0 ;
81289
81290   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81291   arg2 = (Dali::Property::Map *)jarg2;
81292   if (!arg2) {
81293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
81294     return ;
81295   }
81296   {
81297     try {
81298       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
81299     } catch (std::out_of_range& e) {
81300       {
81301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81302       };
81303     } catch (std::exception& e) {
81304       {
81305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81306       };
81307     } catch (...) {
81308       {
81309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81310       };
81311     }
81312   }
81313 }
81314
81315
81316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
81317   void * jresult ;
81318   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
81319   Dali::Toolkit::Visual::Base *result = 0 ;
81320
81321   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
81322   {
81323     try {
81324       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(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_VisualFactory_Get() {
81345   void * jresult ;
81346   Dali::Toolkit::VisualFactory result;
81347
81348   {
81349     try {
81350       result = Dali::Toolkit::VisualFactory::Get();
81351     } catch (std::out_of_range& e) {
81352       {
81353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81354       };
81355     } catch (std::exception& e) {
81356       {
81357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81358       };
81359     } catch (...) {
81360       {
81361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81362       };
81363     }
81364   }
81365   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
81366   return jresult;
81367 }
81368
81369
81370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
81371   void * jresult ;
81372   Dali::Toolkit::VisualFactory *result = 0 ;
81373
81374   {
81375     try {
81376       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391   jresult = (void *)result;
81392   return jresult;
81393 }
81394
81395
81396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
81397   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81398
81399   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81400   {
81401     try {
81402       delete arg1;
81403     } catch (std::out_of_range& e) {
81404       {
81405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81406       };
81407     } catch (std::exception& e) {
81408       {
81409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81410       };
81411     } catch (...) {
81412       {
81413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81414       };
81415     }
81416   }
81417 }
81418
81419
81420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
81421   void * jresult ;
81422   Dali::Toolkit::VisualFactory *arg1 = 0 ;
81423   Dali::Toolkit::VisualFactory *result = 0 ;
81424
81425   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81426   if (!arg1) {
81427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
81428     return 0;
81429   }
81430   {
81431     try {
81432       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
81433     } catch (std::out_of_range& e) {
81434       {
81435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81436       };
81437     } catch (std::exception& e) {
81438       {
81439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81440       };
81441     } catch (...) {
81442       {
81443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81444       };
81445     }
81446   }
81447   jresult = (void *)result;
81448   return jresult;
81449 }
81450
81451
81452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
81453   void * jresult ;
81454   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81455   Dali::Toolkit::VisualFactory *arg2 = 0 ;
81456   Dali::Toolkit::VisualFactory *result = 0 ;
81457
81458   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81459   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
81460   if (!arg2) {
81461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
81462     return 0;
81463   }
81464   {
81465     try {
81466       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
81467     } catch (std::out_of_range& e) {
81468       {
81469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81470       };
81471     } catch (std::exception& e) {
81472       {
81473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81474       };
81475     } catch (...) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81478       };
81479     }
81480   }
81481   jresult = (void *)result;
81482   return jresult;
81483 }
81484
81485
81486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
81487   void * jresult ;
81488   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81489   Dali::Property::Map *arg2 = 0 ;
81490   Dali::Toolkit::Visual::Base result;
81491
81492   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81493   arg2 = (Dali::Property::Map *)jarg2;
81494   if (!arg2) {
81495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
81496     return 0;
81497   }
81498   {
81499     try {
81500       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81508       };
81509     } catch (...) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81512       };
81513     }
81514   }
81515   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
81521   void * jresult ;
81522   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81523   Dali::Image *arg2 = 0 ;
81524   Dali::Toolkit::Visual::Base result;
81525
81526   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81527   arg2 = (Dali::Image *)jarg2;
81528   if (!arg2) {
81529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
81530     return 0;
81531   }
81532   {
81533     try {
81534       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
81535     } catch (std::out_of_range& e) {
81536       {
81537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81538       };
81539     } catch (std::exception& e) {
81540       {
81541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81542       };
81543     } catch (...) {
81544       {
81545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81546       };
81547     }
81548   }
81549   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81550   return jresult;
81551 }
81552
81553
81554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
81555   void * jresult ;
81556   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81557   std::string *arg2 = 0 ;
81558   Dali::ImageDimensions arg3 ;
81559   Dali::ImageDimensions *argp3 ;
81560   Dali::Toolkit::Visual::Base result;
81561
81562   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81563   if (!jarg2) {
81564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81565     return 0;
81566   }
81567   std::string arg2_str(jarg2);
81568   arg2 = &arg2_str;
81569   argp3 = (Dali::ImageDimensions *)jarg3;
81570   if (!argp3) {
81571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81572     return 0;
81573   }
81574   arg3 = *argp3;
81575   {
81576     try {
81577       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
81578     } catch (std::out_of_range& e) {
81579       {
81580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81581       };
81582     } catch (std::exception& e) {
81583       {
81584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81585       };
81586     } catch (...) {
81587       {
81588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81589       };
81590     }
81591   }
81592   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81593
81594   //argout typemap for const std::string&
81595
81596   return jresult;
81597 }
81598
81599
81600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
81601   void * jresult ;
81602   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81603
81604   {
81605     try {
81606       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
81607     } catch (std::out_of_range& e) {
81608       {
81609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81610       };
81611     } catch (std::exception& e) {
81612       {
81613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81614       };
81615     } catch (...) {
81616       {
81617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81618       };
81619     }
81620   }
81621   jresult = (void *)result;
81622   return jresult;
81623 }
81624
81625
81626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
81627   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81628
81629   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81630   {
81631     try {
81632       delete arg1;
81633     } catch (std::out_of_range& e) {
81634       {
81635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81636       };
81637     } catch (std::exception& e) {
81638       {
81639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81640       };
81641     } catch (...) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81644       };
81645     }
81646   }
81647 }
81648
81649
81650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
81651   void * jresult ;
81652   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
81653   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81654
81655   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81656   if (!arg1) {
81657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
81658     return 0;
81659   }
81660   {
81661     try {
81662       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
81663     } catch (std::out_of_range& e) {
81664       {
81665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81666       };
81667     } catch (std::exception& e) {
81668       {
81669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81670       };
81671     } catch (...) {
81672       {
81673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81674       };
81675     }
81676   }
81677   jresult = (void *)result;
81678   return jresult;
81679 }
81680
81681
81682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
81683   void * jresult ;
81684   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81685   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
81686   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81687
81688   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81689   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
81690   if (!arg2) {
81691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
81692     return 0;
81693   }
81694   {
81695     try {
81696       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
81697     } catch (std::out_of_range& e) {
81698       {
81699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (std::exception& e) {
81702       {
81703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81704       };
81705     } catch (...) {
81706       {
81707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81708       };
81709     }
81710   }
81711   jresult = (void *)result;
81712   return jresult;
81713 }
81714
81715
81716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
81717   void * jresult ;
81718   Dali::Toolkit::AsyncImageLoader result;
81719
81720   {
81721     try {
81722       result = Dali::Toolkit::AsyncImageLoader::New();
81723     } catch (std::out_of_range& e) {
81724       {
81725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81726       };
81727     } catch (std::exception& e) {
81728       {
81729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81730       };
81731     } catch (...) {
81732       {
81733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81734       };
81735     }
81736   }
81737   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
81738   return jresult;
81739 }
81740
81741
81742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
81743   void * jresult ;
81744   Dali::BaseHandle arg1 ;
81745   Dali::BaseHandle *argp1 ;
81746   Dali::Toolkit::AsyncImageLoader result;
81747
81748   argp1 = (Dali::BaseHandle *)jarg1;
81749   if (!argp1) {
81750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81751     return 0;
81752   }
81753   arg1 = *argp1;
81754   {
81755     try {
81756       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
81757     } catch (std::out_of_range& e) {
81758       {
81759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81760       };
81761     } catch (std::exception& e) {
81762       {
81763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81764       };
81765     } catch (...) {
81766       {
81767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81768       };
81769     }
81770   }
81771   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
81772   return jresult;
81773 }
81774
81775
81776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
81777   unsigned int jresult ;
81778   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81779   std::string *arg2 = 0 ;
81780   uint32_t result;
81781
81782   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81783   if (!jarg2) {
81784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81785     return 0;
81786   }
81787   std::string arg2_str(jarg2);
81788   arg2 = &arg2_str;
81789   {
81790     try {
81791       result = (arg1)->Load((std::string const &)*arg2);
81792     } catch (std::out_of_range& e) {
81793       {
81794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81795       };
81796     } catch (std::exception& e) {
81797       {
81798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81799       };
81800     } catch (...) {
81801       {
81802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81803       };
81804     }
81805   }
81806   jresult = result;
81807
81808   //argout typemap for const std::string&
81809
81810   return jresult;
81811 }
81812
81813
81814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
81815   unsigned int jresult ;
81816   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81817   std::string *arg2 = 0 ;
81818   Dali::ImageDimensions arg3 ;
81819   Dali::ImageDimensions *argp3 ;
81820   uint32_t result;
81821
81822   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81823   if (!jarg2) {
81824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81825     return 0;
81826   }
81827   std::string arg2_str(jarg2);
81828   arg2 = &arg2_str;
81829   argp3 = (Dali::ImageDimensions *)jarg3;
81830   if (!argp3) {
81831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81832     return 0;
81833   }
81834   arg3 = *argp3;
81835   {
81836     try {
81837       result = (arg1)->Load((std::string const &)*arg2,arg3);
81838     } catch (std::out_of_range& e) {
81839       {
81840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81841       };
81842     } catch (std::exception& e) {
81843       {
81844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81845       };
81846     } catch (...) {
81847       {
81848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81849       };
81850     }
81851   }
81852   jresult = result;
81853
81854   //argout typemap for const std::string&
81855
81856   return jresult;
81857 }
81858
81859
81860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
81861   unsigned int jresult ;
81862   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81863   std::string *arg2 = 0 ;
81864   Dali::ImageDimensions arg3 ;
81865   Dali::FittingMode::Type arg4 ;
81866   Dali::SamplingMode::Type arg5 ;
81867   bool arg6 ;
81868   Dali::ImageDimensions *argp3 ;
81869   uint32_t result;
81870
81871   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81872   if (!jarg2) {
81873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81874     return 0;
81875   }
81876   std::string arg2_str(jarg2);
81877   arg2 = &arg2_str;
81878   argp3 = (Dali::ImageDimensions *)jarg3;
81879   if (!argp3) {
81880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81881     return 0;
81882   }
81883   arg3 = *argp3;
81884   arg4 = (Dali::FittingMode::Type)jarg4;
81885   arg5 = (Dali::SamplingMode::Type)jarg5;
81886   arg6 = jarg6 ? true : false;
81887   {
81888     try {
81889       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
81890     } catch (std::out_of_range& e) {
81891       {
81892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81893       };
81894     } catch (std::exception& e) {
81895       {
81896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81897       };
81898     } catch (...) {
81899       {
81900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81901       };
81902     }
81903   }
81904   jresult = result;
81905
81906   //argout typemap for const std::string&
81907
81908   return jresult;
81909 }
81910
81911
81912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
81913   unsigned int jresult ;
81914   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81915   uint32_t arg2 ;
81916   bool result;
81917
81918   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81919   arg2 = (uint32_t)jarg2;
81920   {
81921     try {
81922       result = (bool)(arg1)->Cancel(arg2);
81923     } catch (std::out_of_range& e) {
81924       {
81925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81926       };
81927     } catch (std::exception& e) {
81928       {
81929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81930       };
81931     } catch (...) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81934       };
81935     }
81936   }
81937   jresult = result;
81938   return jresult;
81939 }
81940
81941
81942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
81943   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81944
81945   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81946   {
81947     try {
81948       (arg1)->CancelAll();
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81956       };
81957     } catch (...) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81960       };
81961     }
81962   }
81963 }
81964
81965
81966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
81967   void * jresult ;
81968   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81969   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
81970
81971   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81972   {
81973     try {
81974       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
81975     } catch (std::out_of_range& e) {
81976       {
81977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81978       };
81979     } catch (std::exception& e) {
81980       {
81981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81982       };
81983     } catch (...) {
81984       {
81985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81986       };
81987     }
81988   }
81989   jresult = (void *)result;
81990   return jresult;
81991 }
81992
81993
81994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
81995   void * jresult ;
81996   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
81997   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81998
81999   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
82000   {
82001     try {
82002       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
82003     } catch (std::out_of_range& e) {
82004       {
82005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82006       };
82007     } catch (std::exception& e) {
82008       {
82009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82010       };
82011     } catch (...) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82014       };
82015     }
82016   }
82017   jresult = (void *)result;
82018   return jresult;
82019 }
82020
82021
82022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
82023   void * jresult ;
82024   std::string *arg1 = 0 ;
82025   Dali::PixelData result;
82026
82027   if (!jarg1) {
82028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82029     return 0;
82030   }
82031   std::string arg1_str(jarg1);
82032   arg1 = &arg1_str;
82033   {
82034     try {
82035       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
82036     } catch (std::out_of_range& e) {
82037       {
82038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82039       };
82040     } catch (std::exception& e) {
82041       {
82042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82043       };
82044     } catch (...) {
82045       {
82046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82047       };
82048     }
82049   }
82050   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82051
82052   //argout typemap for const std::string&
82053
82054   return jresult;
82055 }
82056
82057
82058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
82059   void * jresult ;
82060   std::string *arg1 = 0 ;
82061   Dali::ImageDimensions arg2 ;
82062   Dali::ImageDimensions *argp2 ;
82063   Dali::PixelData result;
82064
82065   if (!jarg1) {
82066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82067     return 0;
82068   }
82069   std::string arg1_str(jarg1);
82070   arg1 = &arg1_str;
82071   argp2 = (Dali::ImageDimensions *)jarg2;
82072   if (!argp2) {
82073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
82074     return 0;
82075   }
82076   arg2 = *argp2;
82077   {
82078     try {
82079       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
82080     } catch (std::out_of_range& e) {
82081       {
82082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82083       };
82084     } catch (std::exception& e) {
82085       {
82086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82087       };
82088     } catch (...) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82091       };
82092     }
82093   }
82094   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82095
82096   //argout typemap for const std::string&
82097
82098   return jresult;
82099 }
82100
82101
82102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
82103   void * jresult ;
82104   std::string *arg1 = 0 ;
82105   Dali::ImageDimensions arg2 ;
82106   Dali::FittingMode::Type arg3 ;
82107   Dali::SamplingMode::Type arg4 ;
82108   bool arg5 ;
82109   Dali::ImageDimensions *argp2 ;
82110   Dali::PixelData result;
82111
82112   if (!jarg1) {
82113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82114     return 0;
82115   }
82116   std::string arg1_str(jarg1);
82117   arg1 = &arg1_str;
82118   argp2 = (Dali::ImageDimensions *)jarg2;
82119   if (!argp2) {
82120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
82121     return 0;
82122   }
82123   arg2 = *argp2;
82124   arg3 = (Dali::FittingMode::Type)jarg3;
82125   arg4 = (Dali::SamplingMode::Type)jarg4;
82126   arg5 = jarg5 ? true : false;
82127   {
82128     try {
82129       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
82130     } catch (std::out_of_range& e) {
82131       {
82132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82133       };
82134     } catch (std::exception& e) {
82135       {
82136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82137       };
82138     } catch (...) {
82139       {
82140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82141       };
82142     }
82143   }
82144   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82145
82146   //argout typemap for const std::string&
82147
82148   return jresult;
82149 }
82150
82151
82152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
82153   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
82154
82155   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
82156   {
82157     try {
82158       delete arg1;
82159     } catch (std::out_of_range& e) {
82160       {
82161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82162       };
82163     } catch (std::exception& e) {
82164       {
82165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82166       };
82167     } catch (...) {
82168       {
82169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82170       };
82171     }
82172   }
82173 }
82174
82175
82176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
82177   void * jresult ;
82178   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
82179   Dali::Actor arg2 ;
82180   Dali::Actor arg3 ;
82181   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
82182   Dali::Actor *argp2 ;
82183   Dali::Actor *argp3 ;
82184   Dali::Actor result;
82185
82186   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
82187   argp2 = (Dali::Actor *)jarg2;
82188   if (!argp2) {
82189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82190     return 0;
82191   }
82192   arg2 = *argp2;
82193   argp3 = (Dali::Actor *)jarg3;
82194   if (!argp3) {
82195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82196     return 0;
82197   }
82198   arg3 = *argp3;
82199   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
82200   {
82201     try {
82202       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
82203     } catch (std::out_of_range& e) {
82204       {
82205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82206       };
82207     } catch (std::exception& e) {
82208       {
82209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82210       };
82211     } catch (...) {
82212       {
82213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82214       };
82215     }
82216   }
82217   jresult = new Dali::Actor((const Dali::Actor &)result);
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
82223   void * jresult ;
82224   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
82225
82226   {
82227     try {
82228       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
82229     } catch (std::out_of_range& e) {
82230       {
82231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82232       };
82233     } catch (std::exception& e) {
82234       {
82235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82236       };
82237     } catch (...) {
82238       {
82239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82240       };
82241     }
82242   }
82243   jresult = (void *)result;
82244   return jresult;
82245 }
82246
82247
82248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
82249   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
82250   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
82251   if (director) {
82252     director->swig_connect_director(callback0);
82253   }
82254 }
82255
82256
82257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
82258   KeyboardFocusManager arg1 ;
82259   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
82260   KeyboardFocusManager *argp1 ;
82261
82262   argp1 = (KeyboardFocusManager *)jarg1;
82263   if (!argp1) {
82264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
82265     return ;
82266   }
82267   arg1 = *argp1;
82268   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
82269   if (!arg2) {
82270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
82271     return ;
82272   }
82273   {
82274     try {
82275       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
82276     } catch (std::out_of_range& e) {
82277       {
82278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82279       };
82280     } catch (std::exception& e) {
82281       {
82282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82283       };
82284     } catch (...) {
82285       {
82286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82287       };
82288     }
82289   }
82290 }
82291
82292
82293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
82294   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82295
82296   arg1 = (std::vector< unsigned int > *)jarg1;
82297   {
82298     try {
82299       (arg1)->clear();
82300     } catch (std::out_of_range& e) {
82301       {
82302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82303       };
82304     } catch (std::exception& e) {
82305       {
82306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82307       };
82308     } catch (...) {
82309       {
82310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82311       };
82312     }
82313   }
82314 }
82315
82316
82317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
82318   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82319   unsigned int *arg2 = 0 ;
82320   unsigned int temp2 ;
82321
82322   arg1 = (std::vector< unsigned int > *)jarg1;
82323   temp2 = (unsigned int)jarg2;
82324   arg2 = &temp2;
82325   {
82326     try {
82327       (arg1)->push_back((unsigned int const &)*arg2);
82328     } catch (std::out_of_range& e) {
82329       {
82330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82331       };
82332     } catch (std::exception& e) {
82333       {
82334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82335       };
82336     } catch (...) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82339       };
82340     }
82341   }
82342 }
82343
82344
82345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
82346   unsigned long jresult ;
82347   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82348   std::vector< unsigned int >::size_type result;
82349
82350   arg1 = (std::vector< unsigned int > *)jarg1;
82351   {
82352     try {
82353       result = ((std::vector< unsigned int > const *)arg1)->size();
82354     } catch (std::out_of_range& e) {
82355       {
82356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82357       };
82358     } catch (std::exception& e) {
82359       {
82360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82361       };
82362     } catch (...) {
82363       {
82364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82365       };
82366     }
82367   }
82368   jresult = (unsigned long)result;
82369   return jresult;
82370 }
82371
82372
82373 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
82374   unsigned long jresult ;
82375   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82376   std::vector< unsigned int >::size_type result;
82377
82378   arg1 = (std::vector< unsigned int > *)jarg1;
82379   {
82380     try {
82381       result = ((std::vector< unsigned int > const *)arg1)->capacity();
82382     } catch (std::out_of_range& e) {
82383       {
82384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82385       };
82386     } catch (std::exception& e) {
82387       {
82388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82389       };
82390     } catch (...) {
82391       {
82392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82393       };
82394     }
82395   }
82396   jresult = (unsigned long)result;
82397   return jresult;
82398 }
82399
82400
82401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
82402   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82403   std::vector< unsigned int >::size_type arg2 ;
82404
82405   arg1 = (std::vector< unsigned int > *)jarg1;
82406   arg2 = (std::vector< unsigned int >::size_type)jarg2;
82407   {
82408     try {
82409       (arg1)->reserve(arg2);
82410     } catch (std::out_of_range& e) {
82411       {
82412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82413       };
82414     } catch (std::exception& e) {
82415       {
82416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82417       };
82418     } catch (...) {
82419       {
82420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82421       };
82422     }
82423   }
82424 }
82425
82426
82427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
82428   void * jresult ;
82429   std::vector< unsigned int > *result = 0 ;
82430
82431   {
82432     try {
82433       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
82434     } catch (std::out_of_range& e) {
82435       {
82436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82437       };
82438     } catch (std::exception& e) {
82439       {
82440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82441       };
82442     } catch (...) {
82443       {
82444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82445       };
82446     }
82447   }
82448   jresult = (void *)result;
82449   return jresult;
82450 }
82451
82452
82453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
82454   void * jresult ;
82455   std::vector< unsigned int > *arg1 = 0 ;
82456   std::vector< unsigned int > *result = 0 ;
82457
82458   arg1 = (std::vector< unsigned int > *)jarg1;
82459   if (!arg1) {
82460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82461     return 0;
82462   }
82463   {
82464     try {
82465       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
82466     } catch (std::out_of_range& e) {
82467       {
82468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82469       };
82470     } catch (std::exception& e) {
82471       {
82472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82473       };
82474     } catch (...) {
82475       {
82476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82477       };
82478     }
82479   }
82480   jresult = (void *)result;
82481   return jresult;
82482 }
82483
82484
82485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
82486   void * jresult ;
82487   int arg1 ;
82488   std::vector< unsigned int > *result = 0 ;
82489
82490   arg1 = (int)jarg1;
82491   {
82492     try {
82493       try {
82494         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
82495       }
82496       catch(std::out_of_range &_e) {
82497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82498         return 0;
82499       }
82500
82501     } catch (std::out_of_range& e) {
82502       {
82503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82504       };
82505     } catch (std::exception& e) {
82506       {
82507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82508       };
82509     } catch (...) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82512       };
82513     }
82514   }
82515   jresult = (void *)result;
82516   return jresult;
82517 }
82518
82519
82520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
82521   unsigned int jresult ;
82522   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82523   int arg2 ;
82524   unsigned int result;
82525
82526   arg1 = (std::vector< unsigned int > *)jarg1;
82527   arg2 = (int)jarg2;
82528   {
82529     try {
82530       try {
82531         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
82532       }
82533       catch(std::out_of_range &_e) {
82534         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82535         return 0;
82536       }
82537
82538     } catch (std::out_of_range& e) {
82539       {
82540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82541       };
82542     } catch (std::exception& e) {
82543       {
82544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82545       };
82546     } catch (...) {
82547       {
82548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82549       };
82550     }
82551   }
82552   jresult = result;
82553   return jresult;
82554 }
82555
82556
82557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
82558   unsigned int jresult ;
82559   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82560   int arg2 ;
82561   unsigned int *result = 0 ;
82562
82563   arg1 = (std::vector< unsigned int > *)jarg1;
82564   arg2 = (int)jarg2;
82565   {
82566     try {
82567       try {
82568         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
82569       }
82570       catch(std::out_of_range &_e) {
82571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82572         return 0;
82573       }
82574
82575     } catch (std::out_of_range& e) {
82576       {
82577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82578       };
82579     } catch (std::exception& e) {
82580       {
82581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (...) {
82584       {
82585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82586       };
82587     }
82588   }
82589   jresult = *result;
82590   return jresult;
82591 }
82592
82593
82594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
82595   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82596   int arg2 ;
82597   unsigned int *arg3 = 0 ;
82598   unsigned int temp3 ;
82599
82600   arg1 = (std::vector< unsigned int > *)jarg1;
82601   arg2 = (int)jarg2;
82602   temp3 = (unsigned int)jarg3;
82603   arg3 = &temp3;
82604   {
82605     try {
82606       try {
82607         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
82608       }
82609       catch(std::out_of_range &_e) {
82610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82611         return ;
82612       }
82613
82614     } catch (std::out_of_range& e) {
82615       {
82616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82617       };
82618     } catch (std::exception& e) {
82619       {
82620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82621       };
82622     } catch (...) {
82623       {
82624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82625       };
82626     }
82627   }
82628 }
82629
82630
82631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
82632   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82633   std::vector< unsigned int > *arg2 = 0 ;
82634
82635   arg1 = (std::vector< unsigned int > *)jarg1;
82636   arg2 = (std::vector< unsigned int > *)jarg2;
82637   if (!arg2) {
82638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82639     return ;
82640   }
82641   {
82642     try {
82643       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
82644     } catch (std::out_of_range& e) {
82645       {
82646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82647       };
82648     } catch (std::exception& e) {
82649       {
82650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82651       };
82652     } catch (...) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82655       };
82656     }
82657   }
82658 }
82659
82660
82661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82662   void * jresult ;
82663   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82664   int arg2 ;
82665   int arg3 ;
82666   std::vector< unsigned int > *result = 0 ;
82667
82668   arg1 = (std::vector< unsigned int > *)jarg1;
82669   arg2 = (int)jarg2;
82670   arg3 = (int)jarg3;
82671   {
82672     try {
82673       try {
82674         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
82675       }
82676       catch(std::out_of_range &_e) {
82677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82678         return 0;
82679       }
82680       catch(std::invalid_argument &_e) {
82681         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82682         return 0;
82683       }
82684
82685     } catch (std::out_of_range& e) {
82686       {
82687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82688       };
82689     } catch (std::exception& e) {
82690       {
82691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82692       };
82693     } catch (...) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82696       };
82697     }
82698   }
82699   jresult = (void *)result;
82700   return jresult;
82701 }
82702
82703
82704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
82705   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82706   int arg2 ;
82707   unsigned int *arg3 = 0 ;
82708   unsigned int temp3 ;
82709
82710   arg1 = (std::vector< unsigned int > *)jarg1;
82711   arg2 = (int)jarg2;
82712   temp3 = (unsigned int)jarg3;
82713   arg3 = &temp3;
82714   {
82715     try {
82716       try {
82717         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
82718       }
82719       catch(std::out_of_range &_e) {
82720         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82721         return ;
82722       }
82723
82724     } catch (std::out_of_range& e) {
82725       {
82726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82727       };
82728     } catch (std::exception& e) {
82729       {
82730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82731       };
82732     } catch (...) {
82733       {
82734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82735       };
82736     }
82737   }
82738 }
82739
82740
82741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82742   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82743   int arg2 ;
82744   std::vector< unsigned int > *arg3 = 0 ;
82745
82746   arg1 = (std::vector< unsigned int > *)jarg1;
82747   arg2 = (int)jarg2;
82748   arg3 = (std::vector< unsigned int > *)jarg3;
82749   if (!arg3) {
82750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82751     return ;
82752   }
82753   {
82754     try {
82755       try {
82756         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
82757       }
82758       catch(std::out_of_range &_e) {
82759         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82760         return ;
82761       }
82762
82763     } catch (std::out_of_range& e) {
82764       {
82765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82766       };
82767     } catch (std::exception& e) {
82768       {
82769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82770       };
82771     } catch (...) {
82772       {
82773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82774       };
82775     }
82776   }
82777 }
82778
82779
82780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
82781   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82782   int arg2 ;
82783
82784   arg1 = (std::vector< unsigned int > *)jarg1;
82785   arg2 = (int)jarg2;
82786   {
82787     try {
82788       try {
82789         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
82790       }
82791       catch(std::out_of_range &_e) {
82792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82793         return ;
82794       }
82795
82796     } catch (std::out_of_range& e) {
82797       {
82798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82799       };
82800     } catch (std::exception& e) {
82801       {
82802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82803       };
82804     } catch (...) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82807       };
82808     }
82809   }
82810 }
82811
82812
82813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82814   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82815   int arg2 ;
82816   int arg3 ;
82817
82818   arg1 = (std::vector< unsigned int > *)jarg1;
82819   arg2 = (int)jarg2;
82820   arg3 = (int)jarg3;
82821   {
82822     try {
82823       try {
82824         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
82825       }
82826       catch(std::out_of_range &_e) {
82827         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82828         return ;
82829       }
82830       catch(std::invalid_argument &_e) {
82831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82832         return ;
82833       }
82834
82835     } catch (std::out_of_range& e) {
82836       {
82837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82838       };
82839     } catch (std::exception& e) {
82840       {
82841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82842       };
82843     } catch (...) {
82844       {
82845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82846       };
82847     }
82848   }
82849 }
82850
82851
82852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
82853   void * jresult ;
82854   unsigned int *arg1 = 0 ;
82855   int arg2 ;
82856   unsigned int temp1 ;
82857   std::vector< unsigned int > *result = 0 ;
82858
82859   temp1 = (unsigned int)jarg1;
82860   arg1 = &temp1;
82861   arg2 = (int)jarg2;
82862   {
82863     try {
82864       try {
82865         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
82866       }
82867       catch(std::out_of_range &_e) {
82868         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82869         return 0;
82870       }
82871
82872     } catch (std::out_of_range& e) {
82873       {
82874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82875       };
82876     } catch (std::exception& e) {
82877       {
82878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82879       };
82880     } catch (...) {
82881       {
82882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82883       };
82884     }
82885   }
82886   jresult = (void *)result;
82887   return jresult;
82888 }
82889
82890
82891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
82892   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82893
82894   arg1 = (std::vector< unsigned int > *)jarg1;
82895   {
82896     try {
82897       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
82898     } catch (std::out_of_range& e) {
82899       {
82900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82901       };
82902     } catch (std::exception& e) {
82903       {
82904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82905       };
82906     } catch (...) {
82907       {
82908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82909       };
82910     }
82911   }
82912 }
82913
82914
82915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82916   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82917   int arg2 ;
82918   int arg3 ;
82919
82920   arg1 = (std::vector< unsigned int > *)jarg1;
82921   arg2 = (int)jarg2;
82922   arg3 = (int)jarg3;
82923   {
82924     try {
82925       try {
82926         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82927       }
82928       catch(std::out_of_range &_e) {
82929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82930         return ;
82931       }
82932       catch(std::invalid_argument &_e) {
82933         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82934         return ;
82935       }
82936
82937     } catch (std::out_of_range& e) {
82938       {
82939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82940       };
82941     } catch (std::exception& e) {
82942       {
82943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82944       };
82945     } catch (...) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82948       };
82949     }
82950   }
82951 }
82952
82953
82954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82955   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82956   int arg2 ;
82957   std::vector< unsigned int > *arg3 = 0 ;
82958
82959   arg1 = (std::vector< unsigned int > *)jarg1;
82960   arg2 = (int)jarg2;
82961   arg3 = (std::vector< unsigned int > *)jarg3;
82962   if (!arg3) {
82963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82964     return ;
82965   }
82966   {
82967     try {
82968       try {
82969         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
82970       }
82971       catch(std::out_of_range &_e) {
82972         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82973         return ;
82974       }
82975
82976     } catch (std::out_of_range& e) {
82977       {
82978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82979       };
82980     } catch (std::exception& e) {
82981       {
82982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82983       };
82984     } catch (...) {
82985       {
82986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82987       };
82988     }
82989   }
82990 }
82991
82992
82993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
82994   unsigned int jresult ;
82995   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82996   unsigned int *arg2 = 0 ;
82997   unsigned int temp2 ;
82998   bool result;
82999
83000   arg1 = (std::vector< unsigned int > *)jarg1;
83001   temp2 = (unsigned int)jarg2;
83002   arg2 = &temp2;
83003   {
83004     try {
83005       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
83006     } catch (std::out_of_range& e) {
83007       {
83008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83009       };
83010     } catch (std::exception& e) {
83011       {
83012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83013       };
83014     } catch (...) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83017       };
83018     }
83019   }
83020   jresult = result;
83021   return jresult;
83022 }
83023
83024
83025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
83026   int jresult ;
83027   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83028   unsigned int *arg2 = 0 ;
83029   unsigned int temp2 ;
83030   int result;
83031
83032   arg1 = (std::vector< unsigned int > *)jarg1;
83033   temp2 = (unsigned int)jarg2;
83034   arg2 = &temp2;
83035   {
83036     try {
83037       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
83038     } catch (std::out_of_range& e) {
83039       {
83040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83041       };
83042     } catch (std::exception& e) {
83043       {
83044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83045       };
83046     } catch (...) {
83047       {
83048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83049       };
83050     }
83051   }
83052   jresult = result;
83053   return jresult;
83054 }
83055
83056
83057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
83058   int jresult ;
83059   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83060   unsigned int *arg2 = 0 ;
83061   unsigned int temp2 ;
83062   int result;
83063
83064   arg1 = (std::vector< unsigned int > *)jarg1;
83065   temp2 = (unsigned int)jarg2;
83066   arg2 = &temp2;
83067   {
83068     try {
83069       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
83070     } catch (std::out_of_range& e) {
83071       {
83072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83073       };
83074     } catch (std::exception& e) {
83075       {
83076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83077       };
83078     } catch (...) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83081       };
83082     }
83083   }
83084   jresult = result;
83085   return jresult;
83086 }
83087
83088
83089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
83090   unsigned int jresult ;
83091   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83092   unsigned int *arg2 = 0 ;
83093   unsigned int temp2 ;
83094   bool result;
83095
83096   arg1 = (std::vector< unsigned int > *)jarg1;
83097   temp2 = (unsigned int)jarg2;
83098   arg2 = &temp2;
83099   {
83100     try {
83101       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
83102     } catch (std::out_of_range& e) {
83103       {
83104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83105       };
83106     } catch (std::exception& e) {
83107       {
83108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83109       };
83110     } catch (...) {
83111       {
83112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83113       };
83114     }
83115   }
83116   jresult = result;
83117   return jresult;
83118 }
83119
83120
83121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
83122   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83123
83124   arg1 = (std::vector< unsigned int > *)jarg1;
83125   {
83126     try {
83127       delete arg1;
83128     } catch (std::out_of_range& e) {
83129       {
83130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83131       };
83132     } catch (std::exception& e) {
83133       {
83134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83135       };
83136     } catch (...) {
83137       {
83138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83139       };
83140     }
83141   }
83142 }
83143
83144
83145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
83146   void * jresult ;
83147   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83148
83149   {
83150     try {
83151       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
83152     } catch (std::out_of_range& e) {
83153       {
83154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83155       };
83156     } catch (std::exception& e) {
83157       {
83158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83159       };
83160     } catch (...) {
83161       {
83162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83163       };
83164     }
83165   }
83166   jresult = (void *)result;
83167   return jresult;
83168 }
83169
83170
83171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
83172   void * jresult ;
83173   unsigned int arg1 ;
83174   Dali::Actor arg2 ;
83175   Dali::Actor *argp2 ;
83176   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83177
83178   arg1 = (unsigned int)jarg1;
83179   argp2 = (Dali::Actor *)jarg2;
83180   if (!argp2) {
83181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83182     return 0;
83183   }
83184   arg2 = *argp2;
83185   {
83186     try {
83187       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
83188     } catch (std::out_of_range& e) {
83189       {
83190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83191       };
83192     } catch (std::exception& e) {
83193       {
83194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83195       };
83196     } catch (...) {
83197       {
83198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83199       };
83200     }
83201   }
83202   jresult = (void *)result;
83203   return jresult;
83204 }
83205
83206
83207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
83208   void * jresult ;
83209   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
83210   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83211
83212   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83213   if (!arg1) {
83214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83215     return 0;
83216   }
83217   {
83218     try {
83219       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
83220     } catch (std::out_of_range& e) {
83221       {
83222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83223       };
83224     } catch (std::exception& e) {
83225       {
83226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83227       };
83228     } catch (...) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83231       };
83232     }
83233   }
83234   jresult = (void *)result;
83235   return jresult;
83236 }
83237
83238
83239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
83240   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83241   unsigned int arg2 ;
83242
83243   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83244   arg2 = (unsigned int)jarg2;
83245   if (arg1) (arg1)->first = arg2;
83246 }
83247
83248
83249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
83250   unsigned int jresult ;
83251   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83252   unsigned int result;
83253
83254   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83255   result = (unsigned int) ((arg1)->first);
83256   jresult = result;
83257   return jresult;
83258 }
83259
83260
83261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
83262   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83263   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
83264
83265   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83266   arg2 = (Dali::Actor *)jarg2;
83267   if (arg1) (arg1)->second = *arg2;
83268 }
83269
83270
83271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
83272   void * jresult ;
83273   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83274   Dali::Actor *result = 0 ;
83275
83276   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83277   result = (Dali::Actor *)& ((arg1)->second);
83278   jresult = (void *)result;
83279   return jresult;
83280 }
83281
83282
83283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
83284   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83285
83286   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83287   {
83288     try {
83289       delete arg1;
83290     } catch (std::out_of_range& e) {
83291       {
83292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83293       };
83294     } catch (std::exception& e) {
83295       {
83296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83297       };
83298     } catch (...) {
83299       {
83300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83301       };
83302     }
83303   }
83304 }
83305
83306
83307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
83308   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83309
83310   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83311   {
83312     try {
83313       (arg1)->clear();
83314     } catch (std::out_of_range& e) {
83315       {
83316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83317       };
83318     } catch (std::exception& e) {
83319       {
83320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83321       };
83322     } catch (...) {
83323       {
83324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83325       };
83326     }
83327   }
83328 }
83329
83330
83331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
83332   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83333   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
83334
83335   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83336   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
83337   if (!arg2) {
83338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83339     return ;
83340   }
83341   {
83342     try {
83343       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
83344     } catch (std::out_of_range& e) {
83345       {
83346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83347       };
83348     } catch (std::exception& e) {
83349       {
83350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83351       };
83352     } catch (...) {
83353       {
83354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83355       };
83356     }
83357   }
83358 }
83359
83360
83361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
83362   unsigned long jresult ;
83363   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83364   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
83365
83366   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83367   {
83368     try {
83369       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
83370     } catch (std::out_of_range& e) {
83371       {
83372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83373       };
83374     } catch (std::exception& e) {
83375       {
83376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83377       };
83378     } catch (...) {
83379       {
83380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83381       };
83382     }
83383   }
83384   jresult = (unsigned long)result;
83385   return jresult;
83386 }
83387
83388
83389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
83390   unsigned long jresult ;
83391   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83392   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
83393
83394   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83395   {
83396     try {
83397       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
83398     } catch (std::out_of_range& e) {
83399       {
83400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83401       };
83402     } catch (std::exception& e) {
83403       {
83404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83405       };
83406     } catch (...) {
83407       {
83408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83409       };
83410     }
83411   }
83412   jresult = (unsigned long)result;
83413   return jresult;
83414 }
83415
83416
83417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
83418   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83419   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
83420
83421   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83422   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
83423   {
83424     try {
83425       (arg1)->reserve(arg2);
83426     } catch (std::out_of_range& e) {
83427       {
83428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83429       };
83430     } catch (std::exception& e) {
83431       {
83432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83433       };
83434     } catch (...) {
83435       {
83436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83437       };
83438     }
83439   }
83440 }
83441
83442
83443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
83444   void * jresult ;
83445   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83446
83447   {
83448     try {
83449       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
83450     } catch (std::out_of_range& e) {
83451       {
83452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83453       };
83454     } catch (std::exception& e) {
83455       {
83456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83457       };
83458     } catch (...) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83461       };
83462     }
83463   }
83464   jresult = (void *)result;
83465   return jresult;
83466 }
83467
83468
83469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
83470   void * jresult ;
83471   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
83472   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83473
83474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83475   if (!arg1) {
83476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83477     return 0;
83478   }
83479   {
83480     try {
83481       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);
83482     } catch (std::out_of_range& e) {
83483       {
83484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83485       };
83486     } catch (std::exception& e) {
83487       {
83488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83489       };
83490     } catch (...) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83493       };
83494     }
83495   }
83496   jresult = (void *)result;
83497   return jresult;
83498 }
83499
83500
83501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
83502   void * jresult ;
83503   int arg1 ;
83504   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83505
83506   arg1 = (int)jarg1;
83507   {
83508     try {
83509       try {
83510         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);
83511       }
83512       catch(std::out_of_range &_e) {
83513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83514         return 0;
83515       }
83516
83517     } catch (std::out_of_range& e) {
83518       {
83519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83520       };
83521     } catch (std::exception& e) {
83522       {
83523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83524       };
83525     } catch (...) {
83526       {
83527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83528       };
83529     }
83530   }
83531   jresult = (void *)result;
83532   return jresult;
83533 }
83534
83535
83536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
83537   void * jresult ;
83538   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83539   int arg2 ;
83540   std::pair< unsigned int,Dali::Actor > result;
83541
83542   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83543   arg2 = (int)jarg2;
83544   {
83545     try {
83546       try {
83547         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
83548       }
83549       catch(std::out_of_range &_e) {
83550         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83551         return 0;
83552       }
83553
83554     } catch (std::out_of_range& e) {
83555       {
83556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83557       };
83558     } catch (std::exception& e) {
83559       {
83560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83561       };
83562     } catch (...) {
83563       {
83564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83565       };
83566     }
83567   }
83568   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
83569   return jresult;
83570 }
83571
83572
83573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
83574   void * jresult ;
83575   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83576   int arg2 ;
83577   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83578
83579   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83580   arg2 = (int)jarg2;
83581   {
83582     try {
83583       try {
83584         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
83585       }
83586       catch(std::out_of_range &_e) {
83587         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83588         return 0;
83589       }
83590
83591     } catch (std::out_of_range& e) {
83592       {
83593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83594       };
83595     } catch (std::exception& e) {
83596       {
83597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83598       };
83599     } catch (...) {
83600       {
83601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83602       };
83603     }
83604   }
83605   jresult = (void *)result;
83606   return jresult;
83607 }
83608
83609
83610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
83611   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83612   int arg2 ;
83613   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
83614
83615   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83616   arg2 = (int)jarg2;
83617   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
83618   if (!arg3) {
83619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83620     return ;
83621   }
83622   {
83623     try {
83624       try {
83625         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);
83626       }
83627       catch(std::out_of_range &_e) {
83628         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83629         return ;
83630       }
83631
83632     } catch (std::out_of_range& e) {
83633       {
83634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83635       };
83636     } catch (std::exception& e) {
83637       {
83638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83639       };
83640     } catch (...) {
83641       {
83642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83643       };
83644     }
83645   }
83646 }
83647
83648
83649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
83650   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83651   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
83652
83653   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83654   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
83655   if (!arg2) {
83656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83657     return ;
83658   }
83659   {
83660     try {
83661       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);
83662     } catch (std::out_of_range& e) {
83663       {
83664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83665       };
83666     } catch (std::exception& e) {
83667       {
83668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83669       };
83670     } catch (...) {
83671       {
83672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83673       };
83674     }
83675   }
83676 }
83677
83678
83679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
83680   void * jresult ;
83681   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83682   int arg2 ;
83683   int arg3 ;
83684   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83685
83686   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83687   arg2 = (int)jarg2;
83688   arg3 = (int)jarg3;
83689   {
83690     try {
83691       try {
83692         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);
83693       }
83694       catch(std::out_of_range &_e) {
83695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83696         return 0;
83697       }
83698       catch(std::invalid_argument &_e) {
83699         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83700         return 0;
83701       }
83702
83703     } catch (std::out_of_range& e) {
83704       {
83705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (std::exception& e) {
83708       {
83709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (...) {
83712       {
83713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83714       };
83715     }
83716   }
83717   jresult = (void *)result;
83718   return jresult;
83719 }
83720
83721
83722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
83723   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83724   int arg2 ;
83725   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
83726
83727   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83728   arg2 = (int)jarg2;
83729   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
83730   if (!arg3) {
83731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83732     return ;
83733   }
83734   {
83735     try {
83736       try {
83737         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);
83738       }
83739       catch(std::out_of_range &_e) {
83740         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83741         return ;
83742       }
83743
83744     } catch (std::out_of_range& e) {
83745       {
83746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83747       };
83748     } catch (std::exception& e) {
83749       {
83750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83751       };
83752     } catch (...) {
83753       {
83754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83755       };
83756     }
83757   }
83758 }
83759
83760
83761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
83762   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83763   int arg2 ;
83764   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
83765
83766   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83767   arg2 = (int)jarg2;
83768   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
83769   if (!arg3) {
83770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83771     return ;
83772   }
83773   {
83774     try {
83775       try {
83776         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);
83777       }
83778       catch(std::out_of_range &_e) {
83779         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83780         return ;
83781       }
83782
83783     } catch (std::out_of_range& e) {
83784       {
83785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83786       };
83787     } catch (std::exception& e) {
83788       {
83789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83794       };
83795     }
83796   }
83797 }
83798
83799
83800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
83801   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83802   int arg2 ;
83803
83804   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83805   arg2 = (int)jarg2;
83806   {
83807     try {
83808       try {
83809         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
83810       }
83811       catch(std::out_of_range &_e) {
83812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83813         return ;
83814       }
83815
83816     } catch (std::out_of_range& e) {
83817       {
83818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83819       };
83820     } catch (std::exception& e) {
83821       {
83822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83823       };
83824     } catch (...) {
83825       {
83826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83827       };
83828     }
83829   }
83830 }
83831
83832
83833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
83834   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83835   int arg2 ;
83836   int arg3 ;
83837
83838   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83839   arg2 = (int)jarg2;
83840   arg3 = (int)jarg3;
83841   {
83842     try {
83843       try {
83844         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
83845       }
83846       catch(std::out_of_range &_e) {
83847         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83848         return ;
83849       }
83850       catch(std::invalid_argument &_e) {
83851         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83852         return ;
83853       }
83854
83855     } catch (std::out_of_range& e) {
83856       {
83857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83858       };
83859     } catch (std::exception& e) {
83860       {
83861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83862       };
83863     } catch (...) {
83864       {
83865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83866       };
83867     }
83868   }
83869 }
83870
83871
83872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
83873   void * jresult ;
83874   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
83875   int arg2 ;
83876   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83877
83878   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83879   if (!arg1) {
83880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83881     return 0;
83882   }
83883   arg2 = (int)jarg2;
83884   {
83885     try {
83886       try {
83887         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);
83888       }
83889       catch(std::out_of_range &_e) {
83890         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83891         return 0;
83892       }
83893
83894     } catch (std::out_of_range& e) {
83895       {
83896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83897       };
83898     } catch (std::exception& e) {
83899       {
83900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83901       };
83902     } catch (...) {
83903       {
83904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83905       };
83906     }
83907   }
83908   jresult = (void *)result;
83909   return jresult;
83910 }
83911
83912
83913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
83914   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83915
83916   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83917   {
83918     try {
83919       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
83920     } catch (std::out_of_range& e) {
83921       {
83922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83923       };
83924     } catch (std::exception& e) {
83925       {
83926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83927       };
83928     } catch (...) {
83929       {
83930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83931       };
83932     }
83933   }
83934 }
83935
83936
83937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
83938   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83939   int arg2 ;
83940   int arg3 ;
83941
83942   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83943   arg2 = (int)jarg2;
83944   arg3 = (int)jarg3;
83945   {
83946     try {
83947       try {
83948         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
83949       }
83950       catch(std::out_of_range &_e) {
83951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83952         return ;
83953       }
83954       catch(std::invalid_argument &_e) {
83955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83956         return ;
83957       }
83958
83959     } catch (std::out_of_range& e) {
83960       {
83961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83962       };
83963     } catch (std::exception& e) {
83964       {
83965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83966       };
83967     } catch (...) {
83968       {
83969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83970       };
83971     }
83972   }
83973 }
83974
83975
83976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
83977   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83978   int arg2 ;
83979   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
83980
83981   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83982   arg2 = (int)jarg2;
83983   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
83984   if (!arg3) {
83985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83986     return ;
83987   }
83988   {
83989     try {
83990       try {
83991         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);
83992       }
83993       catch(std::out_of_range &_e) {
83994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83995         return ;
83996       }
83997
83998     } catch (std::out_of_range& e) {
83999       {
84000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84001       };
84002     } catch (std::exception& e) {
84003       {
84004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84005       };
84006     } catch (...) {
84007       {
84008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84009       };
84010     }
84011   }
84012 }
84013
84014
84015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
84016   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
84017
84018   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
84019   {
84020     try {
84021       delete arg1;
84022     } catch (std::out_of_range& e) {
84023       {
84024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84025       };
84026     } catch (std::exception& e) {
84027       {
84028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84029       };
84030     } catch (...) {
84031       {
84032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84033       };
84034     }
84035   }
84036 }
84037
84038
84039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
84040   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84041
84042   arg1 = (std::vector< Dali::Actor > *)jarg1;
84043   {
84044     try {
84045       (arg1)->clear();
84046     } catch (std::out_of_range& e) {
84047       {
84048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84049       };
84050     } catch (std::exception& e) {
84051       {
84052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84053       };
84054     } catch (...) {
84055       {
84056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84057       };
84058     }
84059   }
84060 }
84061
84062
84063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
84064   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84065   Dali::Actor *arg2 = 0 ;
84066
84067   arg1 = (std::vector< Dali::Actor > *)jarg1;
84068   arg2 = (Dali::Actor *)jarg2;
84069   if (!arg2) {
84070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84071     return ;
84072   }
84073   {
84074     try {
84075       (arg1)->push_back((Dali::Actor const &)*arg2);
84076     } catch (std::out_of_range& e) {
84077       {
84078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84079       };
84080     } catch (std::exception& e) {
84081       {
84082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84083       };
84084     } catch (...) {
84085       {
84086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84087       };
84088     }
84089   }
84090 }
84091
84092
84093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
84094   unsigned long jresult ;
84095   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84096   std::vector< Dali::Actor >::size_type result;
84097
84098   arg1 = (std::vector< Dali::Actor > *)jarg1;
84099   {
84100     try {
84101       result = ((std::vector< Dali::Actor > const *)arg1)->size();
84102     } catch (std::out_of_range& e) {
84103       {
84104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84105       };
84106     } catch (std::exception& e) {
84107       {
84108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84109       };
84110     } catch (...) {
84111       {
84112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84113       };
84114     }
84115   }
84116   jresult = (unsigned long)result;
84117   return jresult;
84118 }
84119
84120
84121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
84122   unsigned long jresult ;
84123   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84124   std::vector< Dali::Actor >::size_type result;
84125
84126   arg1 = (std::vector< Dali::Actor > *)jarg1;
84127   {
84128     try {
84129       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
84130     } catch (std::out_of_range& e) {
84131       {
84132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84133       };
84134     } catch (std::exception& e) {
84135       {
84136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84137       };
84138     } catch (...) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84141       };
84142     }
84143   }
84144   jresult = (unsigned long)result;
84145   return jresult;
84146 }
84147
84148
84149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
84150   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84151   std::vector< Dali::Actor >::size_type arg2 ;
84152
84153   arg1 = (std::vector< Dali::Actor > *)jarg1;
84154   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
84155   {
84156     try {
84157       (arg1)->reserve(arg2);
84158     } catch (std::out_of_range& e) {
84159       {
84160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84161       };
84162     } catch (std::exception& e) {
84163       {
84164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84165       };
84166     } catch (...) {
84167       {
84168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84169       };
84170     }
84171   }
84172 }
84173
84174
84175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
84176   void * jresult ;
84177   std::vector< Dali::Actor > *result = 0 ;
84178
84179   {
84180     try {
84181       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
84182     } catch (std::out_of_range& e) {
84183       {
84184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84185       };
84186     } catch (std::exception& e) {
84187       {
84188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84189       };
84190     } catch (...) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84193       };
84194     }
84195   }
84196   jresult = (void *)result;
84197   return jresult;
84198 }
84199
84200
84201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
84202   void * jresult ;
84203   std::vector< Dali::Actor > *arg1 = 0 ;
84204   std::vector< Dali::Actor > *result = 0 ;
84205
84206   arg1 = (std::vector< Dali::Actor > *)jarg1;
84207   if (!arg1) {
84208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84209     return 0;
84210   }
84211   {
84212     try {
84213       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
84214     } catch (std::out_of_range& e) {
84215       {
84216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84217       };
84218     } catch (std::exception& e) {
84219       {
84220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84221       };
84222     } catch (...) {
84223       {
84224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84225       };
84226     }
84227   }
84228   jresult = (void *)result;
84229   return jresult;
84230 }
84231
84232
84233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
84234   void * jresult ;
84235   int arg1 ;
84236   std::vector< Dali::Actor > *result = 0 ;
84237
84238   arg1 = (int)jarg1;
84239   {
84240     try {
84241       try {
84242         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
84243       }
84244       catch(std::out_of_range &_e) {
84245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84246         return 0;
84247       }
84248
84249     } catch (std::out_of_range& e) {
84250       {
84251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84252       };
84253     } catch (std::exception& e) {
84254       {
84255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84256       };
84257     } catch (...) {
84258       {
84259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84260       };
84261     }
84262   }
84263   jresult = (void *)result;
84264   return jresult;
84265 }
84266
84267
84268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
84269   void * jresult ;
84270   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84271   int arg2 ;
84272   Dali::Actor result;
84273
84274   arg1 = (std::vector< Dali::Actor > *)jarg1;
84275   arg2 = (int)jarg2;
84276   {
84277     try {
84278       try {
84279         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
84280       }
84281       catch(std::out_of_range &_e) {
84282         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84283         return 0;
84284       }
84285
84286     } catch (std::out_of_range& e) {
84287       {
84288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84289       };
84290     } catch (std::exception& e) {
84291       {
84292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84293       };
84294     } catch (...) {
84295       {
84296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84297       };
84298     }
84299   }
84300   jresult = new Dali::Actor((const Dali::Actor &)result);
84301   return jresult;
84302 }
84303
84304
84305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
84306   void * jresult ;
84307   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84308   int arg2 ;
84309   Dali::Actor *result = 0 ;
84310
84311   arg1 = (std::vector< Dali::Actor > *)jarg1;
84312   arg2 = (int)jarg2;
84313   {
84314     try {
84315       try {
84316         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
84317       }
84318       catch(std::out_of_range &_e) {
84319         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84320         return 0;
84321       }
84322
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 = (void *)result;
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
84343   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84344   int arg2 ;
84345   Dali::Actor *arg3 = 0 ;
84346
84347   arg1 = (std::vector< Dali::Actor > *)jarg1;
84348   arg2 = (int)jarg2;
84349   arg3 = (Dali::Actor *)jarg3;
84350   if (!arg3) {
84351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84352     return ;
84353   }
84354   {
84355     try {
84356       try {
84357         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
84358       }
84359       catch(std::out_of_range &_e) {
84360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84361         return ;
84362       }
84363
84364     } catch (std::out_of_range& e) {
84365       {
84366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84367       };
84368     } catch (std::exception& e) {
84369       {
84370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84371       };
84372     } catch (...) {
84373       {
84374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84375       };
84376     }
84377   }
84378 }
84379
84380
84381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
84382   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84383   std::vector< Dali::Actor > *arg2 = 0 ;
84384
84385   arg1 = (std::vector< Dali::Actor > *)jarg1;
84386   arg2 = (std::vector< Dali::Actor > *)jarg2;
84387   if (!arg2) {
84388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84389     return ;
84390   }
84391   {
84392     try {
84393       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
84394     } catch (std::out_of_range& e) {
84395       {
84396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84397       };
84398     } catch (std::exception& e) {
84399       {
84400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84401       };
84402     } catch (...) {
84403       {
84404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84405       };
84406     }
84407   }
84408 }
84409
84410
84411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
84412   void * jresult ;
84413   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84414   int arg2 ;
84415   int arg3 ;
84416   std::vector< Dali::Actor > *result = 0 ;
84417
84418   arg1 = (std::vector< Dali::Actor > *)jarg1;
84419   arg2 = (int)jarg2;
84420   arg3 = (int)jarg3;
84421   {
84422     try {
84423       try {
84424         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
84425       }
84426       catch(std::out_of_range &_e) {
84427         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84428         return 0;
84429       }
84430       catch(std::invalid_argument &_e) {
84431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84432         return 0;
84433       }
84434
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84446       };
84447     }
84448   }
84449   jresult = (void *)result;
84450   return jresult;
84451 }
84452
84453
84454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
84455   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84456   int arg2 ;
84457   Dali::Actor *arg3 = 0 ;
84458
84459   arg1 = (std::vector< Dali::Actor > *)jarg1;
84460   arg2 = (int)jarg2;
84461   arg3 = (Dali::Actor *)jarg3;
84462   if (!arg3) {
84463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84464     return ;
84465   }
84466   {
84467     try {
84468       try {
84469         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
84470       }
84471       catch(std::out_of_range &_e) {
84472         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84473         return ;
84474       }
84475
84476     } catch (std::out_of_range& e) {
84477       {
84478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84479       };
84480     } catch (std::exception& e) {
84481       {
84482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84483       };
84484     } catch (...) {
84485       {
84486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84487       };
84488     }
84489   }
84490 }
84491
84492
84493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
84494   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84495   int arg2 ;
84496   std::vector< Dali::Actor > *arg3 = 0 ;
84497
84498   arg1 = (std::vector< Dali::Actor > *)jarg1;
84499   arg2 = (int)jarg2;
84500   arg3 = (std::vector< Dali::Actor > *)jarg3;
84501   if (!arg3) {
84502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84503     return ;
84504   }
84505   {
84506     try {
84507       try {
84508         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
84509       }
84510       catch(std::out_of_range &_e) {
84511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84512         return ;
84513       }
84514
84515     } catch (std::out_of_range& e) {
84516       {
84517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84518       };
84519     } catch (std::exception& e) {
84520       {
84521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84522       };
84523     } catch (...) {
84524       {
84525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84526       };
84527     }
84528   }
84529 }
84530
84531
84532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
84533   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84534   int arg2 ;
84535
84536   arg1 = (std::vector< Dali::Actor > *)jarg1;
84537   arg2 = (int)jarg2;
84538   {
84539     try {
84540       try {
84541         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
84542       }
84543       catch(std::out_of_range &_e) {
84544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84545         return ;
84546       }
84547
84548     } catch (std::out_of_range& e) {
84549       {
84550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84551       };
84552     } catch (std::exception& e) {
84553       {
84554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84555       };
84556     } catch (...) {
84557       {
84558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84559       };
84560     }
84561   }
84562 }
84563
84564
84565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
84566   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84567   int arg2 ;
84568   int arg3 ;
84569
84570   arg1 = (std::vector< Dali::Actor > *)jarg1;
84571   arg2 = (int)jarg2;
84572   arg3 = (int)jarg3;
84573   {
84574     try {
84575       try {
84576         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
84577       }
84578       catch(std::out_of_range &_e) {
84579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84580         return ;
84581       }
84582       catch(std::invalid_argument &_e) {
84583         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84584         return ;
84585       }
84586
84587     } catch (std::out_of_range& e) {
84588       {
84589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84590       };
84591     } catch (std::exception& e) {
84592       {
84593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84594       };
84595     } catch (...) {
84596       {
84597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84598       };
84599     }
84600   }
84601 }
84602
84603
84604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
84605   void * jresult ;
84606   Dali::Actor *arg1 = 0 ;
84607   int arg2 ;
84608   std::vector< Dali::Actor > *result = 0 ;
84609
84610   arg1 = (Dali::Actor *)jarg1;
84611   if (!arg1) {
84612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84613     return 0;
84614   }
84615   arg2 = (int)jarg2;
84616   {
84617     try {
84618       try {
84619         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
84620       }
84621       catch(std::out_of_range &_e) {
84622         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84623         return 0;
84624       }
84625
84626     } catch (std::out_of_range& e) {
84627       {
84628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84629       };
84630     } catch (std::exception& e) {
84631       {
84632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84633       };
84634     } catch (...) {
84635       {
84636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84637       };
84638     }
84639   }
84640   jresult = (void *)result;
84641   return jresult;
84642 }
84643
84644
84645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
84646   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84647
84648   arg1 = (std::vector< Dali::Actor > *)jarg1;
84649   {
84650     try {
84651       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
84652     } catch (std::out_of_range& e) {
84653       {
84654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84655       };
84656     } catch (std::exception& e) {
84657       {
84658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84659       };
84660     } catch (...) {
84661       {
84662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84663       };
84664     }
84665   }
84666 }
84667
84668
84669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
84670   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84671   int arg2 ;
84672   int arg3 ;
84673
84674   arg1 = (std::vector< Dali::Actor > *)jarg1;
84675   arg2 = (int)jarg2;
84676   arg3 = (int)jarg3;
84677   {
84678     try {
84679       try {
84680         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
84681       }
84682       catch(std::out_of_range &_e) {
84683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84684         return ;
84685       }
84686       catch(std::invalid_argument &_e) {
84687         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84688         return ;
84689       }
84690
84691     } catch (std::out_of_range& e) {
84692       {
84693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84694       };
84695     } catch (std::exception& e) {
84696       {
84697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84698       };
84699     } catch (...) {
84700       {
84701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84702       };
84703     }
84704   }
84705 }
84706
84707
84708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
84709   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84710   int arg2 ;
84711   std::vector< Dali::Actor > *arg3 = 0 ;
84712
84713   arg1 = (std::vector< Dali::Actor > *)jarg1;
84714   arg2 = (int)jarg2;
84715   arg3 = (std::vector< Dali::Actor > *)jarg3;
84716   if (!arg3) {
84717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84718     return ;
84719   }
84720   {
84721     try {
84722       try {
84723         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
84724       }
84725       catch(std::out_of_range &_e) {
84726         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84727         return ;
84728       }
84729
84730     } catch (std::out_of_range& e) {
84731       {
84732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84733       };
84734     } catch (std::exception& e) {
84735       {
84736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84737       };
84738     } catch (...) {
84739       {
84740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84741       };
84742     }
84743   }
84744 }
84745
84746
84747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
84748   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84749
84750   arg1 = (std::vector< Dali::Actor > *)jarg1;
84751   {
84752     try {
84753       delete arg1;
84754     } catch (std::out_of_range& e) {
84755       {
84756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84757       };
84758     } catch (std::exception& e) {
84759       {
84760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84761       };
84762     } catch (...) {
84763       {
84764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84765       };
84766     }
84767   }
84768 }
84769
84770
84771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
84772   unsigned int jresult ;
84773   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84774   bool result;
84775
84776   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84777   {
84778     try {
84779       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
84780     } catch (std::out_of_range& e) {
84781       {
84782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84783       };
84784     } catch (std::exception& e) {
84785       {
84786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (...) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84791       };
84792     }
84793   }
84794   jresult = result;
84795   return jresult;
84796 }
84797
84798
84799 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
84800   unsigned long jresult ;
84801   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84802   std::size_t result;
84803
84804   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84805   {
84806     try {
84807       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
84808     } catch (std::out_of_range& e) {
84809       {
84810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84811       };
84812     } catch (std::exception& e) {
84813       {
84814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84815       };
84816     } catch (...) {
84817       {
84818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84819       };
84820     }
84821   }
84822   jresult = (unsigned long)result;
84823   return jresult;
84824 }
84825
84826
84827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
84828   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84829   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
84830
84831   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84832   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
84833   {
84834     try {
84835       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
84836     } catch (std::out_of_range& e) {
84837       {
84838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84839       };
84840     } catch (std::exception& e) {
84841       {
84842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84843       };
84844     } catch (...) {
84845       {
84846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84847       };
84848     }
84849   }
84850 }
84851
84852
84853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
84854   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84855   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
84856
84857   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84858   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
84859   {
84860     try {
84861       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
84862     } catch (std::out_of_range& e) {
84863       {
84864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84865       };
84866     } catch (std::exception& e) {
84867       {
84868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84869       };
84870     } catch (...) {
84871       {
84872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84873       };
84874     }
84875   }
84876 }
84877
84878
84879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
84880   unsigned int jresult ;
84881   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84882   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
84883   bool result;
84884
84885   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84886   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
84887   if (!arg2) {
84888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
84889     return 0;
84890   }
84891   {
84892     try {
84893       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
84894     } catch (std::out_of_range& e) {
84895       {
84896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84897       };
84898     } catch (std::exception& e) {
84899       {
84900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84901       };
84902     } catch (...) {
84903       {
84904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84905       };
84906     }
84907   }
84908   jresult = result;
84909   return jresult;
84910 }
84911
84912
84913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
84914   void * jresult ;
84915   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
84916
84917   {
84918     try {
84919       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
84920     } catch (std::out_of_range& e) {
84921       {
84922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84923       };
84924     } catch (std::exception& e) {
84925       {
84926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84927       };
84928     } catch (...) {
84929       {
84930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84931       };
84932     }
84933   }
84934   jresult = (void *)result;
84935   return jresult;
84936 }
84937
84938
84939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
84940   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84941
84942   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84943   {
84944     try {
84945       delete arg1;
84946     } catch (std::out_of_range& e) {
84947       {
84948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84949       };
84950     } catch (std::exception& e) {
84951       {
84952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84953       };
84954     } catch (...) {
84955       {
84956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84957       };
84958     }
84959   }
84960 }
84961
84962
84963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
84964   unsigned int jresult ;
84965   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84966   bool result;
84967
84968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84969   {
84970     try {
84971       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);
84972     } catch (std::out_of_range& e) {
84973       {
84974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84975       };
84976     } catch (std::exception& e) {
84977       {
84978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84979       };
84980     } catch (...) {
84981       {
84982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84983       };
84984     }
84985   }
84986   jresult = result;
84987   return jresult;
84988 }
84989
84990
84991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
84992   unsigned long jresult ;
84993   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84994   std::size_t result;
84995
84996   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84997   {
84998     try {
84999       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);
85000     } catch (std::out_of_range& e) {
85001       {
85002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85003       };
85004     } catch (std::exception& e) {
85005       {
85006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85007       };
85008     } catch (...) {
85009       {
85010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85011       };
85012     }
85013   }
85014   jresult = (unsigned long)result;
85015   return jresult;
85016 }
85017
85018
85019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
85020   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85021   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
85022
85023   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85024   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
85025   {
85026     try {
85027       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
85028     } catch (std::out_of_range& e) {
85029       {
85030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85031       };
85032     } catch (std::exception& e) {
85033       {
85034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85035       };
85036     } catch (...) {
85037       {
85038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85039       };
85040     }
85041   }
85042 }
85043
85044
85045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
85046   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85047   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
85048
85049   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85050   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
85051   {
85052     try {
85053       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
85054     } catch (std::out_of_range& e) {
85055       {
85056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85057       };
85058     } catch (std::exception& e) {
85059       {
85060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85061       };
85062     } catch (...) {
85063       {
85064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85065       };
85066     }
85067   }
85068 }
85069
85070
85071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85072   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85073   Dali::Actor arg2 ;
85074   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
85075   Dali::Actor *argp2 ;
85076
85077   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85078   argp2 = (Dali::Actor *)jarg2;
85079   if (!argp2) {
85080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85081     return ;
85082   }
85083   arg2 = *argp2;
85084   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
85085   {
85086     try {
85087       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
85088     } catch (std::out_of_range& e) {
85089       {
85090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85091       };
85092     } catch (std::exception& e) {
85093       {
85094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85095       };
85096     } catch (...) {
85097       {
85098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85099       };
85100     }
85101   }
85102 }
85103
85104
85105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
85106   void * jresult ;
85107   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
85108
85109   {
85110     try {
85111       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85123       };
85124     }
85125   }
85126   jresult = (void *)result;
85127   return jresult;
85128 }
85129
85130
85131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
85132   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85133
85134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85135   {
85136     try {
85137       delete arg1;
85138     } catch (std::out_of_range& e) {
85139       {
85140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85141       };
85142     } catch (std::exception& e) {
85143       {
85144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85145       };
85146     } catch (...) {
85147       {
85148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85149       };
85150     }
85151   }
85152 }
85153
85154
85155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
85156   unsigned int jresult ;
85157   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85158   bool result;
85159
85160   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85161   {
85162     try {
85163       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
85164     } catch (std::out_of_range& e) {
85165       {
85166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85167       };
85168     } catch (std::exception& e) {
85169       {
85170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85171       };
85172     } catch (...) {
85173       {
85174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85175       };
85176     }
85177   }
85178   jresult = result;
85179   return jresult;
85180 }
85181
85182
85183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
85184   unsigned long jresult ;
85185   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85186   std::size_t result;
85187
85188   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85189   {
85190     try {
85191       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
85192     } catch (std::out_of_range& e) {
85193       {
85194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85195       };
85196     } catch (std::exception& e) {
85197       {
85198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85199       };
85200     } catch (...) {
85201       {
85202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85203       };
85204     }
85205   }
85206   jresult = (unsigned long)result;
85207   return jresult;
85208 }
85209
85210
85211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
85212   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85213   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
85214
85215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85216   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
85217   {
85218     try {
85219       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
85220     } catch (std::out_of_range& e) {
85221       {
85222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85223       };
85224     } catch (std::exception& e) {
85225       {
85226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85227       };
85228     } catch (...) {
85229       {
85230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85231       };
85232     }
85233   }
85234 }
85235
85236
85237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85238   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85239   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
85240
85241   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85242   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
85243   {
85244     try {
85245       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85257       };
85258     }
85259   }
85260 }
85261
85262
85263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
85264   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85265   Dali::Actor arg2 ;
85266   Dali::Actor arg3 ;
85267   Dali::Actor *argp2 ;
85268   Dali::Actor *argp3 ;
85269
85270   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85271   argp2 = (Dali::Actor *)jarg2;
85272   if (!argp2) {
85273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85274     return ;
85275   }
85276   arg2 = *argp2;
85277   argp3 = (Dali::Actor *)jarg3;
85278   if (!argp3) {
85279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85280     return ;
85281   }
85282   arg3 = *argp3;
85283   {
85284     try {
85285       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
85286     } catch (std::out_of_range& e) {
85287       {
85288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85289       };
85290     } catch (std::exception& e) {
85291       {
85292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85293       };
85294     } catch (...) {
85295       {
85296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85297       };
85298     }
85299   }
85300 }
85301
85302
85303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
85304   void * jresult ;
85305   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
85306
85307   {
85308     try {
85309       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
85310     } catch (std::out_of_range& e) {
85311       {
85312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (std::exception& e) {
85315       {
85316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85317       };
85318     } catch (...) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85321       };
85322     }
85323   }
85324   jresult = (void *)result;
85325   return jresult;
85326 }
85327
85328
85329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
85330   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85331
85332   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85333   {
85334     try {
85335       delete arg1;
85336     } catch (std::out_of_range& e) {
85337       {
85338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85339       };
85340     } catch (std::exception& e) {
85341       {
85342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85343       };
85344     } catch (...) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85347       };
85348     }
85349   }
85350 }
85351
85352
85353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
85354   unsigned int jresult ;
85355   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85356   bool result;
85357
85358   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85359   {
85360     try {
85361       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
85362     } catch (std::out_of_range& e) {
85363       {
85364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85365       };
85366     } catch (std::exception& e) {
85367       {
85368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85369       };
85370     } catch (...) {
85371       {
85372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85373       };
85374     }
85375   }
85376   jresult = result;
85377   return jresult;
85378 }
85379
85380
85381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
85382   unsigned long jresult ;
85383   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85384   std::size_t result;
85385
85386   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85387   {
85388     try {
85389       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
85390     } catch (std::out_of_range& e) {
85391       {
85392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85393       };
85394     } catch (std::exception& e) {
85395       {
85396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85397       };
85398     } catch (...) {
85399       {
85400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85401       };
85402     }
85403   }
85404   jresult = (unsigned long)result;
85405   return jresult;
85406 }
85407
85408
85409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
85410   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85411   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
85412
85413   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85414   arg2 = (void (*)(Dali::Actor,bool))jarg2;
85415   {
85416     try {
85417       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
85418     } catch (std::out_of_range& e) {
85419       {
85420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85421       };
85422     } catch (std::exception& e) {
85423       {
85424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85425       };
85426     } catch (...) {
85427       {
85428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85429       };
85430     }
85431   }
85432 }
85433
85434
85435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85436   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85437   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
85438
85439   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85440   arg2 = (void (*)(Dali::Actor,bool))jarg2;
85441   {
85442     try {
85443       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
85444     } catch (std::out_of_range& e) {
85445       {
85446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85447       };
85448     } catch (std::exception& e) {
85449       {
85450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85451       };
85452     } catch (...) {
85453       {
85454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85455       };
85456     }
85457   }
85458 }
85459
85460
85461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
85462   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85463   Dali::Actor arg2 ;
85464   bool arg3 ;
85465   Dali::Actor *argp2 ;
85466
85467   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85468   argp2 = (Dali::Actor *)jarg2;
85469   if (!argp2) {
85470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85471     return ;
85472   }
85473   arg2 = *argp2;
85474   arg3 = jarg3 ? true : false;
85475   {
85476     try {
85477       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
85478     } catch (std::out_of_range& e) {
85479       {
85480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85481       };
85482     } catch (std::exception& e) {
85483       {
85484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85485       };
85486     } catch (...) {
85487       {
85488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85489       };
85490     }
85491   }
85492 }
85493
85494
85495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
85496   void * jresult ;
85497   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
85498
85499   {
85500     try {
85501       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
85502     } catch (std::out_of_range& e) {
85503       {
85504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85505       };
85506     } catch (std::exception& e) {
85507       {
85508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85509       };
85510     } catch (...) {
85511       {
85512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85513       };
85514     }
85515   }
85516   jresult = (void *)result;
85517   return jresult;
85518 }
85519
85520
85521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
85522   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85523
85524   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85525   {
85526     try {
85527       delete arg1;
85528     } catch (std::out_of_range& e) {
85529       {
85530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85531       };
85532     } catch (std::exception& e) {
85533       {
85534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85535       };
85536     } catch (...) {
85537       {
85538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85539       };
85540     }
85541   }
85542 }
85543
85544
85545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
85546   unsigned int jresult ;
85547   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85548   bool result;
85549
85550   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85551   {
85552     try {
85553       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);
85554     } catch (std::out_of_range& e) {
85555       {
85556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85557       };
85558     } catch (std::exception& e) {
85559       {
85560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85561       };
85562     } catch (...) {
85563       {
85564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85565       };
85566     }
85567   }
85568   jresult = result;
85569   return jresult;
85570 }
85571
85572
85573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
85574   unsigned long jresult ;
85575   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85576   std::size_t result;
85577
85578   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85579   {
85580     try {
85581       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);
85582     } catch (std::out_of_range& e) {
85583       {
85584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85585       };
85586     } catch (std::exception& e) {
85587       {
85588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85589       };
85590     } catch (...) {
85591       {
85592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85593       };
85594     }
85595   }
85596   jresult = (unsigned long)result;
85597   return jresult;
85598 }
85599
85600
85601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
85602   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85603   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
85604
85605   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85606   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
85607   {
85608     try {
85609       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
85610     } catch (std::out_of_range& e) {
85611       {
85612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85613       };
85614     } catch (std::exception& e) {
85615       {
85616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85617       };
85618     } catch (...) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85621       };
85622     }
85623   }
85624 }
85625
85626
85627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85628   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85629   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
85630
85631   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85632   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
85633   {
85634     try {
85635       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
85636     } catch (std::out_of_range& e) {
85637       {
85638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85639       };
85640     } catch (std::exception& e) {
85641       {
85642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85643       };
85644     } catch (...) {
85645       {
85646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85647       };
85648     }
85649   }
85650 }
85651
85652
85653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85654   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85655   Dali::Toolkit::StyleManager arg2 ;
85656   Dali::StyleChange::Type arg3 ;
85657   Dali::Toolkit::StyleManager *argp2 ;
85658
85659   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85660   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
85661   if (!argp2) {
85662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
85663     return ;
85664   }
85665   arg2 = *argp2;
85666   arg3 = (Dali::StyleChange::Type)jarg3;
85667   {
85668     try {
85669       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
85670     } catch (std::out_of_range& e) {
85671       {
85672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85673       };
85674     } catch (std::exception& e) {
85675       {
85676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85677       };
85678     } catch (...) {
85679       {
85680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85681       };
85682     }
85683   }
85684 }
85685
85686
85687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
85688   void * jresult ;
85689   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
85690
85691   {
85692     try {
85693       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
85694     } catch (std::out_of_range& e) {
85695       {
85696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85697       };
85698     } catch (std::exception& e) {
85699       {
85700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85701       };
85702     } catch (...) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85705       };
85706     }
85707   }
85708   jresult = (void *)result;
85709   return jresult;
85710 }
85711
85712
85713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
85714   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85715
85716   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85717   {
85718     try {
85719       delete arg1;
85720     } catch (std::out_of_range& e) {
85721       {
85722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85723       };
85724     } catch (std::exception& e) {
85725       {
85726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85727       };
85728     } catch (...) {
85729       {
85730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85731       };
85732     }
85733   }
85734 }
85735
85736
85737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
85738   unsigned int jresult ;
85739   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85740   bool result;
85741
85742   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85743   {
85744     try {
85745       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
85746     } catch (std::out_of_range& e) {
85747       {
85748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85749       };
85750     } catch (std::exception& e) {
85751       {
85752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85753       };
85754     } catch (...) {
85755       {
85756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85757       };
85758     }
85759   }
85760   jresult = result;
85761   return jresult;
85762 }
85763
85764
85765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
85766   unsigned long jresult ;
85767   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85768   std::size_t result;
85769
85770   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85771   {
85772     try {
85773       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
85774     } catch (std::out_of_range& e) {
85775       {
85776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85777       };
85778     } catch (std::exception& e) {
85779       {
85780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85781       };
85782     } catch (...) {
85783       {
85784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85785       };
85786     }
85787   }
85788   jresult = (unsigned long)result;
85789   return jresult;
85790 }
85791
85792
85793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
85794   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85795   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
85796
85797   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85798   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
85799   {
85800     try {
85801       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
85802     } catch (std::out_of_range& e) {
85803       {
85804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85805       };
85806     } catch (std::exception& e) {
85807       {
85808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85809       };
85810     } catch (...) {
85811       {
85812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85813       };
85814     }
85815   }
85816 }
85817
85818
85819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
85820   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85821   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
85822
85823   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85824   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
85825   {
85826     try {
85827       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
85828     } catch (std::out_of_range& e) {
85829       {
85830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85831       };
85832     } catch (std::exception& e) {
85833       {
85834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85835       };
85836     } catch (...) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85839       };
85840     }
85841   }
85842 }
85843
85844
85845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
85846   unsigned int jresult ;
85847   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85848   Dali::Toolkit::Button arg2 ;
85849   Dali::Toolkit::Button *argp2 ;
85850   bool result;
85851
85852   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85853   argp2 = (Dali::Toolkit::Button *)jarg2;
85854   if (!argp2) {
85855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
85856     return 0;
85857   }
85858   arg2 = *argp2;
85859   {
85860     try {
85861       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
85862     } catch (std::out_of_range& e) {
85863       {
85864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85865       };
85866     } catch (std::exception& e) {
85867       {
85868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85869       };
85870     } catch (...) {
85871       {
85872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85873       };
85874     }
85875   }
85876   jresult = result;
85877   return jresult;
85878 }
85879
85880
85881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
85882   void * jresult ;
85883   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
85884
85885   {
85886     try {
85887       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
85888     } catch (std::out_of_range& e) {
85889       {
85890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85891       };
85892     } catch (std::exception& e) {
85893       {
85894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85895       };
85896     } catch (...) {
85897       {
85898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85899       };
85900     }
85901   }
85902   jresult = (void *)result;
85903   return jresult;
85904 }
85905
85906
85907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
85908   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85909
85910   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85911   {
85912     try {
85913       delete arg1;
85914     } catch (std::out_of_range& e) {
85915       {
85916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85917       };
85918     } catch (std::exception& e) {
85919       {
85920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85921       };
85922     } catch (...) {
85923       {
85924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85925       };
85926     }
85927   }
85928 }
85929
85930
85931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
85932   unsigned int jresult ;
85933   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85934   bool result;
85935
85936   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85937   {
85938     try {
85939       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
85940     } catch (std::out_of_range& e) {
85941       {
85942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85943       };
85944     } catch (std::exception& e) {
85945       {
85946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85947       };
85948     } catch (...) {
85949       {
85950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85951       };
85952     }
85953   }
85954   jresult = result;
85955   return jresult;
85956 }
85957
85958
85959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
85960   unsigned long jresult ;
85961   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85962   std::size_t result;
85963
85964   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85965   {
85966     try {
85967       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
85968     } catch (std::out_of_range& e) {
85969       {
85970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85971       };
85972     } catch (std::exception& e) {
85973       {
85974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85975       };
85976     } catch (...) {
85977       {
85978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85979       };
85980     }
85981   }
85982   jresult = (unsigned long)result;
85983   return jresult;
85984 }
85985
85986
85987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
85988   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85989   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
85990
85991   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85992   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
85993   {
85994     try {
85995       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
85996     } catch (std::out_of_range& e) {
85997       {
85998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85999       };
86000     } catch (std::exception& e) {
86001       {
86002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86003       };
86004     } catch (...) {
86005       {
86006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86007       };
86008     }
86009   }
86010 }
86011
86012
86013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
86014   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
86015   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
86016
86017   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86018   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
86019   {
86020     try {
86021       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86029       };
86030     } catch (...) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86033       };
86034     }
86035   }
86036 }
86037
86038
86039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
86040   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
86041   Dali::Toolkit::GaussianBlurView arg2 ;
86042   Dali::Toolkit::GaussianBlurView *argp2 ;
86043
86044   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86045   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
86046   if (!argp2) {
86047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
86048     return ;
86049   }
86050   arg2 = *argp2;
86051   {
86052     try {
86053       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
86054     } catch (std::out_of_range& e) {
86055       {
86056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86057       };
86058     } catch (std::exception& e) {
86059       {
86060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86061       };
86062     } catch (...) {
86063       {
86064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86065       };
86066     }
86067   }
86068 }
86069
86070
86071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
86072   void * jresult ;
86073   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
86074
86075   {
86076     try {
86077       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
86078     } catch (std::out_of_range& e) {
86079       {
86080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86081       };
86082     } catch (std::exception& e) {
86083       {
86084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86085       };
86086     } catch (...) {
86087       {
86088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86089       };
86090     }
86091   }
86092   jresult = (void *)result;
86093   return jresult;
86094 }
86095
86096
86097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
86098   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
86099
86100   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86101   {
86102     try {
86103       delete arg1;
86104     } catch (std::out_of_range& e) {
86105       {
86106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86107       };
86108     } catch (std::exception& e) {
86109       {
86110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86111       };
86112     } catch (...) {
86113       {
86114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86115       };
86116     }
86117   }
86118 }
86119
86120
86121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
86122   unsigned int jresult ;
86123   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86124   bool result;
86125
86126   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86127   {
86128     try {
86129       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);
86130     } catch (std::out_of_range& e) {
86131       {
86132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86133       };
86134     } catch (std::exception& e) {
86135       {
86136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (...) {
86139       {
86140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86141       };
86142     }
86143   }
86144   jresult = result;
86145   return jresult;
86146 }
86147
86148
86149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
86150   unsigned long jresult ;
86151   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86152   std::size_t result;
86153
86154   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86155   {
86156     try {
86157       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);
86158     } catch (std::out_of_range& e) {
86159       {
86160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (std::exception& e) {
86163       {
86164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (...) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86169       };
86170     }
86171   }
86172   jresult = (unsigned long)result;
86173   return jresult;
86174 }
86175
86176
86177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
86178   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86179   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
86180
86181   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86182   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
86183   {
86184     try {
86185       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
86186     } catch (std::out_of_range& e) {
86187       {
86188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86189       };
86190     } catch (std::exception& e) {
86191       {
86192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86193       };
86194     } catch (...) {
86195       {
86196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86197       };
86198     }
86199   }
86200 }
86201
86202
86203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
86204   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86205   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
86206
86207   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86208   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
86209   {
86210     try {
86211       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
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_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
86230   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86231   Dali::Toolkit::PageTurnView arg2 ;
86232   unsigned int arg3 ;
86233   bool arg4 ;
86234   Dali::Toolkit::PageTurnView *argp2 ;
86235
86236   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86237   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
86238   if (!argp2) {
86239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
86240     return ;
86241   }
86242   arg2 = *argp2;
86243   arg3 = (unsigned int)jarg3;
86244   arg4 = jarg4 ? true : false;
86245   {
86246     try {
86247       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
86248     } catch (std::out_of_range& e) {
86249       {
86250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86251       };
86252     } catch (std::exception& e) {
86253       {
86254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86255       };
86256     } catch (...) {
86257       {
86258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86259       };
86260     }
86261   }
86262 }
86263
86264
86265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
86266   void * jresult ;
86267   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
86268
86269   {
86270     try {
86271       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
86272     } catch (std::out_of_range& e) {
86273       {
86274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86275       };
86276     } catch (std::exception& e) {
86277       {
86278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86279       };
86280     } catch (...) {
86281       {
86282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86283       };
86284     }
86285   }
86286   jresult = (void *)result;
86287   return jresult;
86288 }
86289
86290
86291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
86292   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86293
86294   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86295   {
86296     try {
86297       delete arg1;
86298     } catch (std::out_of_range& e) {
86299       {
86300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86301       };
86302     } catch (std::exception& e) {
86303       {
86304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86305       };
86306     } catch (...) {
86307       {
86308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86309       };
86310     }
86311   }
86312 }
86313
86314
86315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
86316   unsigned int jresult ;
86317   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86318   bool result;
86319
86320   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86321   {
86322     try {
86323       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
86324     } catch (std::out_of_range& e) {
86325       {
86326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86327       };
86328     } catch (std::exception& e) {
86329       {
86330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (...) {
86333       {
86334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86335       };
86336     }
86337   }
86338   jresult = result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
86344   unsigned long jresult ;
86345   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86346   std::size_t result;
86347
86348   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86349   {
86350     try {
86351       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
86352     } catch (std::out_of_range& e) {
86353       {
86354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86355       };
86356     } catch (std::exception& e) {
86357       {
86358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86359       };
86360     } catch (...) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86363       };
86364     }
86365   }
86366   jresult = (unsigned long)result;
86367   return jresult;
86368 }
86369
86370
86371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
86372   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86373   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
86374
86375   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86376   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
86377   {
86378     try {
86379       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
86380     } catch (std::out_of_range& e) {
86381       {
86382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86383       };
86384     } catch (std::exception& e) {
86385       {
86386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86387       };
86388     } catch (...) {
86389       {
86390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86391       };
86392     }
86393   }
86394 }
86395
86396
86397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
86398   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86399   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
86400
86401   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86402   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
86403   {
86404     try {
86405       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
86406     } catch (std::out_of_range& e) {
86407       {
86408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86409       };
86410     } catch (std::exception& e) {
86411       {
86412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86413       };
86414     } catch (...) {
86415       {
86416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86417       };
86418     }
86419   }
86420 }
86421
86422
86423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
86424   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86425   Dali::Toolkit::PageTurnView arg2 ;
86426   Dali::Toolkit::PageTurnView *argp2 ;
86427
86428   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86429   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
86430   if (!argp2) {
86431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
86432     return ;
86433   }
86434   arg2 = *argp2;
86435   {
86436     try {
86437       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
86438     } catch (std::out_of_range& e) {
86439       {
86440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86441       };
86442     } catch (std::exception& e) {
86443       {
86444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86445       };
86446     } catch (...) {
86447       {
86448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86449       };
86450     }
86451   }
86452 }
86453
86454
86455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
86456   void * jresult ;
86457   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
86458
86459   {
86460     try {
86461       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
86462     } catch (std::out_of_range& e) {
86463       {
86464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (std::exception& e) {
86467       {
86468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86469       };
86470     } catch (...) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86473       };
86474     }
86475   }
86476   jresult = (void *)result;
86477   return jresult;
86478 }
86479
86480
86481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
86482   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86483
86484   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86485   {
86486     try {
86487       delete arg1;
86488     } catch (std::out_of_range& e) {
86489       {
86490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86491       };
86492     } catch (std::exception& e) {
86493       {
86494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86495       };
86496     } catch (...) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86499       };
86500     }
86501   }
86502 }
86503
86504
86505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
86506   unsigned int jresult ;
86507   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86508   bool result;
86509
86510   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86511   {
86512     try {
86513       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);
86514     } catch (std::out_of_range& e) {
86515       {
86516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86517       };
86518     } catch (std::exception& e) {
86519       {
86520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86521       };
86522     } catch (...) {
86523       {
86524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86525       };
86526     }
86527   }
86528   jresult = result;
86529   return jresult;
86530 }
86531
86532
86533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
86534   unsigned long jresult ;
86535   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86536   std::size_t result;
86537
86538   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86539   {
86540     try {
86541       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);
86542     } catch (std::out_of_range& e) {
86543       {
86544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86545       };
86546     } catch (std::exception& e) {
86547       {
86548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86549       };
86550     } catch (...) {
86551       {
86552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86553       };
86554     }
86555   }
86556   jresult = (unsigned long)result;
86557   return jresult;
86558 }
86559
86560
86561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
86562   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86563   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
86564
86565   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86566   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
86567   {
86568     try {
86569       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
86570     } catch (std::out_of_range& e) {
86571       {
86572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86573       };
86574     } catch (std::exception& e) {
86575       {
86576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86577       };
86578     } catch (...) {
86579       {
86580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86581       };
86582     }
86583   }
86584 }
86585
86586
86587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
86588   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86589   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
86590
86591   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86592   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
86593   {
86594     try {
86595       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
86596     } catch (std::out_of_range& e) {
86597       {
86598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86599       };
86600     } catch (std::exception& e) {
86601       {
86602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86603       };
86604     } catch (...) {
86605       {
86606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86607       };
86608     }
86609   }
86610 }
86611
86612
86613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
86614   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86615   Dali::Toolkit::ProgressBar arg2 ;
86616   float arg3 ;
86617   float arg4 ;
86618   Dali::Toolkit::ProgressBar *argp2 ;
86619
86620   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86621   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
86622   if (!argp2) {
86623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
86624     return ;
86625   }
86626   arg2 = *argp2;
86627   arg3 = (float)jarg3;
86628   arg4 = (float)jarg4;
86629   {
86630     try {
86631       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
86632     } catch (std::out_of_range& e) {
86633       {
86634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86635       };
86636     } catch (std::exception& e) {
86637       {
86638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86639       };
86640     } catch (...) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86643       };
86644     }
86645   }
86646 }
86647
86648
86649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
86650   void * jresult ;
86651   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
86652
86653   {
86654     try {
86655       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
86656     } catch (std::out_of_range& e) {
86657       {
86658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86659       };
86660     } catch (std::exception& e) {
86661       {
86662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86663       };
86664     } catch (...) {
86665       {
86666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86667       };
86668     }
86669   }
86670   jresult = (void *)result;
86671   return jresult;
86672 }
86673
86674
86675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
86676   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86677
86678   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86679   {
86680     try {
86681       delete arg1;
86682     } catch (std::out_of_range& e) {
86683       {
86684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86685       };
86686     } catch (std::exception& e) {
86687       {
86688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86689       };
86690     } catch (...) {
86691       {
86692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86693       };
86694     }
86695   }
86696 }
86697
86698
86699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
86700   unsigned int jresult ;
86701   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86702   bool result;
86703
86704   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86705   {
86706     try {
86707       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);
86708     } catch (std::out_of_range& e) {
86709       {
86710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86711       };
86712     } catch (std::exception& e) {
86713       {
86714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86715       };
86716     } catch (...) {
86717       {
86718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86719       };
86720     }
86721   }
86722   jresult = result;
86723   return jresult;
86724 }
86725
86726
86727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
86728   unsigned long jresult ;
86729   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86730   std::size_t result;
86731
86732   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86733   {
86734     try {
86735       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);
86736     } catch (std::out_of_range& e) {
86737       {
86738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86739       };
86740     } catch (std::exception& e) {
86741       {
86742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86743       };
86744     } catch (...) {
86745       {
86746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86747       };
86748     }
86749   }
86750   jresult = (unsigned long)result;
86751   return jresult;
86752 }
86753
86754
86755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
86756   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86757   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
86758
86759   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86760   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
86761   {
86762     try {
86763       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86764     } catch (std::out_of_range& e) {
86765       {
86766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86767       };
86768     } catch (std::exception& e) {
86769       {
86770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86771       };
86772     } catch (...) {
86773       {
86774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86775       };
86776     }
86777   }
86778 }
86779
86780
86781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
86782   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86783   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
86784
86785   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86786   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
86787   {
86788     try {
86789       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86790     } catch (std::out_of_range& e) {
86791       {
86792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86793       };
86794     } catch (std::exception& e) {
86795       {
86796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86797       };
86798     } catch (...) {
86799       {
86800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86801       };
86802     }
86803   }
86804 }
86805
86806
86807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
86808   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86809   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
86810
86811   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86812   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
86813   if (!arg2) {
86814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
86815     return ;
86816   }
86817   {
86818     try {
86819       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
86820     } catch (std::out_of_range& e) {
86821       {
86822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86823       };
86824     } catch (std::exception& e) {
86825       {
86826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86827       };
86828     } catch (...) {
86829       {
86830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86831       };
86832     }
86833   }
86834 }
86835
86836
86837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
86838   void * jresult ;
86839   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
86840
86841   {
86842     try {
86843       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
86844     } catch (std::out_of_range& e) {
86845       {
86846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86847       };
86848     } catch (std::exception& e) {
86849       {
86850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (...) {
86853       {
86854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86855       };
86856     }
86857   }
86858   jresult = (void *)result;
86859   return jresult;
86860 }
86861
86862
86863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
86864   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86865
86866   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86867   {
86868     try {
86869       delete arg1;
86870     } catch (std::out_of_range& e) {
86871       {
86872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86873       };
86874     } catch (std::exception& e) {
86875       {
86876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86877       };
86878     } catch (...) {
86879       {
86880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86881       };
86882     }
86883   }
86884 }
86885
86886
86887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
86888   unsigned int jresult ;
86889   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86890   bool result;
86891
86892   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86893   {
86894     try {
86895       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
86896     } catch (std::out_of_range& e) {
86897       {
86898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86899       };
86900     } catch (std::exception& e) {
86901       {
86902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86903       };
86904     } catch (...) {
86905       {
86906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86907       };
86908     }
86909   }
86910   jresult = result;
86911   return jresult;
86912 }
86913
86914
86915 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
86916   unsigned long jresult ;
86917   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86918   std::size_t result;
86919
86920   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86921   {
86922     try {
86923       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
86924     } catch (std::out_of_range& e) {
86925       {
86926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (std::exception& e) {
86929       {
86930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86931       };
86932     } catch (...) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86935       };
86936     }
86937   }
86938   jresult = (unsigned long)result;
86939   return jresult;
86940 }
86941
86942
86943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
86944   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86945   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
86946
86947   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86948   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
86949   {
86950     try {
86951       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86952     } catch (std::out_of_range& e) {
86953       {
86954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86955       };
86956     } catch (std::exception& e) {
86957       {
86958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86959       };
86960     } catch (...) {
86961       {
86962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86963       };
86964     }
86965   }
86966 }
86967
86968
86969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
86970   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86971   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
86972
86973   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86974   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
86975   {
86976     try {
86977       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86978     } catch (std::out_of_range& e) {
86979       {
86980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86981       };
86982     } catch (std::exception& e) {
86983       {
86984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86985       };
86986     } catch (...) {
86987       {
86988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86989       };
86990     }
86991   }
86992 }
86993
86994
86995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
86996   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86997   Dali::Vector2 *arg2 = 0 ;
86998
86999   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
87000   arg2 = (Dali::Vector2 *)jarg2;
87001   if (!arg2) {
87002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
87003     return ;
87004   }
87005   {
87006     try {
87007       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
87008     } catch (std::out_of_range& e) {
87009       {
87010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87011       };
87012     } catch (std::exception& e) {
87013       {
87014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87015       };
87016     } catch (...) {
87017       {
87018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87019       };
87020     }
87021   }
87022 }
87023
87024
87025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
87026   void * jresult ;
87027   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
87028
87029   {
87030     try {
87031       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
87032     } catch (std::out_of_range& e) {
87033       {
87034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87035       };
87036     } catch (std::exception& e) {
87037       {
87038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87039       };
87040     } catch (...) {
87041       {
87042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87043       };
87044     }
87045   }
87046   jresult = (void *)result;
87047   return jresult;
87048 }
87049
87050
87051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
87052   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
87053
87054   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
87055   {
87056     try {
87057       delete arg1;
87058     } catch (std::out_of_range& e) {
87059       {
87060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87061       };
87062     } catch (std::exception& e) {
87063       {
87064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87065       };
87066     } catch (...) {
87067       {
87068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87069       };
87070     }
87071   }
87072 }
87073
87074
87075
87076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
87077   unsigned int jresult ;
87078   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87079   bool result;
87080
87081   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87082   {
87083     try {
87084       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);
87085     } catch (std::out_of_range& e) {
87086       {
87087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87088       };
87089     } catch (std::exception& e) {
87090       {
87091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87092       };
87093     } catch (...) {
87094       {
87095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87096       };
87097     }
87098   }
87099   jresult = result;
87100   return jresult;
87101 }
87102
87103
87104 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
87105   unsigned long jresult ;
87106   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87107   std::size_t result;
87108
87109   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87110   {
87111     try {
87112       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);
87113     } catch (std::out_of_range& e) {
87114       {
87115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87116       };
87117     } catch (std::exception& e) {
87118       {
87119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87120       };
87121     } catch (...) {
87122       {
87123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87124       };
87125     }
87126   }
87127   jresult = (unsigned long)result;
87128   return jresult;
87129 }
87130
87131
87132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
87133   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87134   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
87135
87136   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87137   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
87138   {
87139     try {
87140       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
87141     } catch (std::out_of_range& e) {
87142       {
87143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87144       };
87145     } catch (std::exception& e) {
87146       {
87147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87148       };
87149     } catch (...) {
87150       {
87151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87152       };
87153     }
87154   }
87155 }
87156
87157
87158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
87159   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87160   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
87161
87162   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87163   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
87164   {
87165     try {
87166       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
87167     } catch (std::out_of_range& e) {
87168       {
87169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87170       };
87171     } catch (std::exception& e) {
87172       {
87173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87174       };
87175     } catch (...) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87178       };
87179     }
87180   }
87181 }
87182
87183
87184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
87185   unsigned int jresult ;
87186   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87187   Dali::Toolkit::Control arg2 ;
87188   Dali::KeyEvent *arg3 = 0 ;
87189   Dali::Toolkit::Control *argp2 ;
87190   bool result;
87191
87192   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87193   argp2 = (Dali::Toolkit::Control *)jarg2;
87194   if (!argp2) {
87195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87196     return 0;
87197   }
87198   arg2 = *argp2;
87199   arg3 = (Dali::KeyEvent *)jarg3;
87200   if (!arg3) {
87201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
87202     return 0;
87203   }
87204   {
87205     try {
87206       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);
87207     } catch (std::out_of_range& e) {
87208       {
87209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87210       };
87211     } catch (std::exception& e) {
87212       {
87213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87214       };
87215     } catch (...) {
87216       {
87217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87218       };
87219     }
87220   }
87221   jresult = result;
87222   return jresult;
87223 }
87224
87225
87226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
87227   void * jresult ;
87228   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
87229
87230   {
87231     try {
87232       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
87233     } catch (std::out_of_range& e) {
87234       {
87235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87236       };
87237     } catch (std::exception& e) {
87238       {
87239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87240       };
87241     } catch (...) {
87242       {
87243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87244       };
87245     }
87246   }
87247   jresult = (void *)result;
87248   return jresult;
87249 }
87250
87251
87252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
87253   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87254
87255   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87256   {
87257     try {
87258       delete arg1;
87259     } catch (std::out_of_range& e) {
87260       {
87261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87262       };
87263     } catch (std::exception& e) {
87264       {
87265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87266       };
87267     } catch (...) {
87268       {
87269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87270       };
87271     }
87272   }
87273 }
87274
87275
87276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
87277   unsigned int jresult ;
87278   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87279   bool result;
87280
87281   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87282   {
87283     try {
87284       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87285     } catch (std::out_of_range& e) {
87286       {
87287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87288       };
87289     } catch (std::exception& e) {
87290       {
87291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87292       };
87293     } catch (...) {
87294       {
87295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87296       };
87297     }
87298   }
87299   jresult = result;
87300   return jresult;
87301 }
87302
87303
87304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
87305   unsigned long jresult ;
87306   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87307   std::size_t result;
87308
87309   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87310   {
87311     try {
87312       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87313     } catch (std::out_of_range& e) {
87314       {
87315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87316       };
87317     } catch (std::exception& e) {
87318       {
87319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87320       };
87321     } catch (...) {
87322       {
87323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87324       };
87325     }
87326   }
87327   jresult = (unsigned long)result;
87328   return jresult;
87329 }
87330
87331
87332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
87333   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87334   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87335
87336   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87337   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87338   {
87339     try {
87340       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
87341     } catch (std::out_of_range& e) {
87342       {
87343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87344       };
87345     } catch (std::exception& e) {
87346       {
87347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87348       };
87349     } catch (...) {
87350       {
87351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87352       };
87353     }
87354   }
87355 }
87356
87357
87358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
87359   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87360   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87361
87362   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87363   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87364   {
87365     try {
87366       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
87367     } catch (std::out_of_range& e) {
87368       {
87369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87370       };
87371     } catch (std::exception& e) {
87372       {
87373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87374       };
87375     } catch (...) {
87376       {
87377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87378       };
87379     }
87380   }
87381 }
87382
87383
87384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
87385   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87386   Dali::Toolkit::Control arg2 ;
87387   Dali::Toolkit::Control *argp2 ;
87388
87389   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87390   argp2 = (Dali::Toolkit::Control *)jarg2;
87391   if (!argp2) {
87392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87393     return ;
87394   }
87395   arg2 = *argp2;
87396   {
87397     try {
87398       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87399     } catch (std::out_of_range& e) {
87400       {
87401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87402       };
87403     } catch (std::exception& e) {
87404       {
87405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87406       };
87407     } catch (...) {
87408       {
87409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87410       };
87411     }
87412   }
87413 }
87414
87415
87416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
87417   void * jresult ;
87418   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87419
87420   {
87421     try {
87422       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87423     } catch (std::out_of_range& e) {
87424       {
87425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (std::exception& e) {
87428       {
87429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87430       };
87431     } catch (...) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87434       };
87435     }
87436   }
87437   jresult = (void *)result;
87438   return jresult;
87439 }
87440
87441
87442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
87443   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87444
87445   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87446   {
87447     try {
87448       delete arg1;
87449     } catch (std::out_of_range& e) {
87450       {
87451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87452       };
87453     } catch (std::exception& e) {
87454       {
87455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87456       };
87457     } catch (...) {
87458       {
87459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87460       };
87461     }
87462   }
87463 }
87464
87465
87466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
87467   unsigned int jresult ;
87468   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87469   bool result;
87470
87471   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87472   {
87473     try {
87474       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
87475     } catch (std::out_of_range& e) {
87476       {
87477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87478       };
87479     } catch (std::exception& e) {
87480       {
87481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87482       };
87483     } catch (...) {
87484       {
87485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87486       };
87487     }
87488   }
87489   jresult = result;
87490   return jresult;
87491 }
87492
87493
87494 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
87495   unsigned long jresult ;
87496   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87497   std::size_t result;
87498
87499   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87500   {
87501     try {
87502       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
87503     } catch (std::out_of_range& e) {
87504       {
87505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87506       };
87507     } catch (std::exception& e) {
87508       {
87509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87510       };
87511     } catch (...) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87514       };
87515     }
87516   }
87517   jresult = (unsigned long)result;
87518   return jresult;
87519 }
87520
87521
87522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
87523   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87524   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
87525
87526   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87527   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
87528   {
87529     try {
87530       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
87531     } catch (std::out_of_range& e) {
87532       {
87533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87534       };
87535     } catch (std::exception& e) {
87536       {
87537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87538       };
87539     } catch (...) {
87540       {
87541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87542       };
87543     }
87544   }
87545 }
87546
87547
87548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
87549   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87550   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
87551
87552   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87553   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
87554   {
87555     try {
87556       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
87557     } catch (std::out_of_range& e) {
87558       {
87559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87560       };
87561     } catch (std::exception& e) {
87562       {
87563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87564       };
87565     } catch (...) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87568       };
87569     }
87570   }
87571 }
87572
87573
87574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
87575   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87576   Dali::Toolkit::VideoView *arg2 = 0 ;
87577
87578   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87579   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87580   if (!arg2) {
87581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
87582     return ;
87583   }
87584   {
87585     try {
87586       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
87587     } catch (std::out_of_range& e) {
87588       {
87589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87590       };
87591     } catch (std::exception& e) {
87592       {
87593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87594       };
87595     } catch (...) {
87596       {
87597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87598       };
87599     }
87600   }
87601 }
87602
87603
87604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
87605   void * jresult ;
87606   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
87607
87608   {
87609     try {
87610       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
87611     } catch (std::out_of_range& e) {
87612       {
87613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87614       };
87615     } catch (std::exception& e) {
87616       {
87617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87618       };
87619     } catch (...) {
87620       {
87621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87622       };
87623     }
87624   }
87625   jresult = (void *)result;
87626   return jresult;
87627 }
87628
87629
87630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
87631   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87632
87633   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87634   {
87635     try {
87636       delete arg1;
87637     } catch (std::out_of_range& e) {
87638       {
87639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87640       };
87641     } catch (std::exception& e) {
87642       {
87643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87644       };
87645     } catch (...) {
87646       {
87647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87648       };
87649     }
87650   }
87651 }
87652
87653
87654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
87655   unsigned int jresult ;
87656   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87657   bool result;
87658
87659   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87660   {
87661     try {
87662       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
87663     } catch (std::out_of_range& e) {
87664       {
87665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87666       };
87667     } catch (std::exception& e) {
87668       {
87669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87670       };
87671     } catch (...) {
87672       {
87673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87674       };
87675     }
87676   }
87677   jresult = result;
87678   return jresult;
87679 }
87680
87681
87682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
87683   unsigned long jresult ;
87684   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87685   std::size_t result;
87686
87687   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87688   {
87689     try {
87690       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
87691     } catch (std::out_of_range& e) {
87692       {
87693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87694       };
87695     } catch (std::exception& e) {
87696       {
87697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87698       };
87699     } catch (...) {
87700       {
87701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87702       };
87703     }
87704   }
87705   jresult = (unsigned long)result;
87706   return jresult;
87707 }
87708
87709
87710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
87711   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87712   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
87713
87714   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87715   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
87716   {
87717     try {
87718       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
87719     } catch (std::out_of_range& e) {
87720       {
87721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87722       };
87723     } catch (std::exception& e) {
87724       {
87725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87726       };
87727     } catch (...) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87730       };
87731     }
87732   }
87733 }
87734
87735
87736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
87737   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87738   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
87739
87740   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87741   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
87742   {
87743     try {
87744       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
87745     } catch (std::out_of_range& e) {
87746       {
87747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87748       };
87749     } catch (std::exception& e) {
87750       {
87751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87752       };
87753     } catch (...) {
87754       {
87755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87756       };
87757     }
87758   }
87759 }
87760
87761
87762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
87763   unsigned int jresult ;
87764   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87765   Dali::Toolkit::Slider arg2 ;
87766   float arg3 ;
87767   Dali::Toolkit::Slider *argp2 ;
87768   bool result;
87769
87770   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87771   argp2 = (Dali::Toolkit::Slider *)jarg2;
87772   if (!argp2) {
87773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
87774     return 0;
87775   }
87776   arg2 = *argp2;
87777   arg3 = (float)jarg3;
87778   {
87779     try {
87780       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
87781     } catch (std::out_of_range& e) {
87782       {
87783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87784       };
87785     } catch (std::exception& e) {
87786       {
87787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87788       };
87789     } catch (...) {
87790       {
87791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87792       };
87793     }
87794   }
87795   jresult = result;
87796   return jresult;
87797 }
87798
87799
87800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
87801   void * jresult ;
87802   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
87803
87804   {
87805     try {
87806       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
87807     } catch (std::out_of_range& e) {
87808       {
87809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87810       };
87811     } catch (std::exception& e) {
87812       {
87813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87814       };
87815     } catch (...) {
87816       {
87817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87818       };
87819     }
87820   }
87821   jresult = (void *)result;
87822   return jresult;
87823 }
87824
87825
87826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
87827   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87828
87829   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87830   {
87831     try {
87832       delete arg1;
87833     } catch (std::out_of_range& e) {
87834       {
87835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87836       };
87837     } catch (std::exception& e) {
87838       {
87839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87840       };
87841     } catch (...) {
87842       {
87843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87844       };
87845     }
87846   }
87847 }
87848
87849
87850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
87851   unsigned int jresult ;
87852   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87853   bool result;
87854
87855   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87856   {
87857     try {
87858       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
87859     } catch (std::out_of_range& e) {
87860       {
87861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87862       };
87863     } catch (std::exception& e) {
87864       {
87865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87866       };
87867     } catch (...) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87870       };
87871     }
87872   }
87873   jresult = result;
87874   return jresult;
87875 }
87876
87877
87878 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
87879   unsigned long jresult ;
87880   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87881   std::size_t result;
87882
87883   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87884   {
87885     try {
87886       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
87887     } catch (std::out_of_range& e) {
87888       {
87889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87890       };
87891     } catch (std::exception& e) {
87892       {
87893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87894       };
87895     } catch (...) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87898       };
87899     }
87900   }
87901   jresult = (unsigned long)result;
87902   return jresult;
87903 }
87904
87905
87906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
87907   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87908   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
87909
87910   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87911   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
87912   {
87913     try {
87914       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
87915     } catch (std::out_of_range& e) {
87916       {
87917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87918       };
87919     } catch (std::exception& e) {
87920       {
87921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87922       };
87923     } catch (...) {
87924       {
87925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87926       };
87927     }
87928   }
87929 }
87930
87931
87932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
87933   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87934   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
87935
87936   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87937   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
87938   {
87939     try {
87940       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
87941     } catch (std::out_of_range& e) {
87942       {
87943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87944       };
87945     } catch (std::exception& e) {
87946       {
87947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87948       };
87949     } catch (...) {
87950       {
87951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87952       };
87953     }
87954   }
87955 }
87956
87957
87958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
87959   unsigned int jresult ;
87960   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87961   Dali::Toolkit::Slider arg2 ;
87962   int arg3 ;
87963   Dali::Toolkit::Slider *argp2 ;
87964   bool result;
87965
87966   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87967   argp2 = (Dali::Toolkit::Slider *)jarg2;
87968   if (!argp2) {
87969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
87970     return 0;
87971   }
87972   arg2 = *argp2;
87973   arg3 = (int)jarg3;
87974   {
87975     try {
87976       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
87977     } catch (std::out_of_range& e) {
87978       {
87979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87980       };
87981     } catch (std::exception& e) {
87982       {
87983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87984       };
87985     } catch (...) {
87986       {
87987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87988       };
87989     }
87990   }
87991   jresult = result;
87992   return jresult;
87993 }
87994
87995
87996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
87997   void * jresult ;
87998   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
87999
88000   {
88001     try {
88002       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
88003     } catch (std::out_of_range& e) {
88004       {
88005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88006       };
88007     } catch (std::exception& e) {
88008       {
88009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88010       };
88011     } catch (...) {
88012       {
88013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88014       };
88015     }
88016   }
88017   jresult = (void *)result;
88018   return jresult;
88019 }
88020
88021
88022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
88023   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
88024
88025   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
88026   {
88027     try {
88028       delete arg1;
88029     } catch (std::out_of_range& e) {
88030       {
88031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88032       };
88033     } catch (std::exception& e) {
88034       {
88035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88036       };
88037     } catch (...) {
88038       {
88039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88040       };
88041     }
88042   }
88043 }
88044
88045
88046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
88047   void * jresult ;
88048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88049
88050   {
88051     try {
88052       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
88053     } catch (std::out_of_range& e) {
88054       {
88055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88056       };
88057     } catch (std::exception& e) {
88058       {
88059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88060       };
88061     } catch (...) {
88062       {
88063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88064       };
88065     }
88066   }
88067   jresult = (void *)result;
88068   return jresult;
88069 }
88070
88071
88072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
88073   void * jresult ;
88074   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
88075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88076
88077   arg1 = (Dali::Toolkit::Ruler *)jarg1;
88078   {
88079     try {
88080       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
88081     } catch (std::out_of_range& e) {
88082       {
88083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88084       };
88085     } catch (std::exception& e) {
88086       {
88087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88088       };
88089     } catch (...) {
88090       {
88091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88092       };
88093     }
88094   }
88095   jresult = (void *)result;
88096   return jresult;
88097 }
88098
88099
88100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
88101   void * jresult ;
88102   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
88103   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88104
88105   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88106   if (!arg1) {
88107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
88108     return 0;
88109   }
88110   {
88111     try {
88112       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
88113     } catch (std::out_of_range& e) {
88114       {
88115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88116       };
88117     } catch (std::exception& e) {
88118       {
88119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (...) {
88122       {
88123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88124       };
88125     }
88126   }
88127   jresult = (void *)result;
88128   return jresult;
88129 }
88130
88131
88132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
88133   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88134
88135   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88136   {
88137     try {
88138       delete arg1;
88139     } catch (std::out_of_range& e) {
88140       {
88141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88142       };
88143     } catch (std::exception& e) {
88144       {
88145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88146       };
88147     } catch (...) {
88148       {
88149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88150       };
88151     }
88152   }
88153 }
88154
88155
88156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
88157   void * jresult ;
88158   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88159   Dali::Toolkit::Ruler *result = 0 ;
88160
88161   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88162   {
88163     try {
88164       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
88165     } catch (std::out_of_range& e) {
88166       {
88167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88168       };
88169     } catch (std::exception& e) {
88170       {
88171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88172       };
88173     } catch (...) {
88174       {
88175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88176       };
88177     }
88178   }
88179   jresult = (void *)result;
88180   return jresult;
88181 }
88182
88183
88184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
88185   void * jresult ;
88186   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88187   Dali::Toolkit::Ruler *result = 0 ;
88188
88189   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88190   {
88191     try {
88192       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
88193     } catch (std::out_of_range& e) {
88194       {
88195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (std::exception& e) {
88198       {
88199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88200       };
88201     } catch (...) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88204       };
88205     }
88206   }
88207   jresult = (void *)result;
88208   return jresult;
88209 }
88210
88211
88212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
88213   void * jresult ;
88214   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88215   Dali::Toolkit::Ruler *result = 0 ;
88216
88217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88218   {
88219     try {
88220       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
88221     } catch (std::out_of_range& e) {
88222       {
88223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88224       };
88225     } catch (std::exception& e) {
88226       {
88227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88228       };
88229     } catch (...) {
88230       {
88231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88232       };
88233     }
88234   }
88235   jresult = (void *)result;
88236   return jresult;
88237 }
88238
88239
88240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
88241   void * jresult ;
88242   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88243   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
88244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88245
88246   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88247   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
88248   if (!arg2) {
88249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
88250     return 0;
88251   }
88252   {
88253     try {
88254       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
88255     } catch (std::out_of_range& e) {
88256       {
88257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88258       };
88259     } catch (std::exception& e) {
88260       {
88261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88262       };
88263     } catch (...) {
88264       {
88265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88266       };
88267     }
88268   }
88269   jresult = (void *)result;
88270   return jresult;
88271 }
88272
88273
88274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
88275   void * jresult ;
88276   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88277   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
88278   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88279
88280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88281   arg2 = (Dali::Toolkit::Ruler *)jarg2;
88282   {
88283     try {
88284       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
88285     } catch (std::out_of_range& e) {
88286       {
88287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88288       };
88289     } catch (std::exception& e) {
88290       {
88291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88292       };
88293     } catch (...) {
88294       {
88295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88296       };
88297     }
88298   }
88299   jresult = (void *)result;
88300   return jresult;
88301 }
88302
88303
88304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
88305   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88306
88307   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88308   {
88309     try {
88310       (arg1)->Reset();
88311     } catch (std::out_of_range& e) {
88312       {
88313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88314       };
88315     } catch (std::exception& e) {
88316       {
88317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88318       };
88319     } catch (...) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88322       };
88323     }
88324   }
88325 }
88326
88327
88328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
88329   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88330   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
88331
88332   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88333   arg2 = (Dali::Toolkit::Ruler *)jarg2;
88334   {
88335     try {
88336       (arg1)->Reset(arg2);
88337     } catch (std::out_of_range& e) {
88338       {
88339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88340       };
88341     } catch (std::exception& e) {
88342       {
88343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88344       };
88345     } catch (...) {
88346       {
88347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88348       };
88349     }
88350   }
88351 }
88352
88353
88354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
88355   void * jresult ;
88356   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88357   Dali::Toolkit::Ruler *result = 0 ;
88358
88359   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88360   {
88361     try {
88362       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
88363     } catch (std::out_of_range& e) {
88364       {
88365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88366       };
88367     } catch (std::exception& e) {
88368       {
88369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88370       };
88371     } catch (...) {
88372       {
88373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88374       };
88375     }
88376   }
88377   jresult = (void *)result;
88378   return jresult;
88379 }
88380
88381
88382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
88383   float jresult ;
88384   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88385   float arg2 ;
88386   float arg3 ;
88387   float result;
88388
88389   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88390   arg2 = (float)jarg2;
88391   arg3 = (float)jarg3;
88392   {
88393     try {
88394       result = (float)(*arg1)->Snap(arg2,arg3);
88395     } catch (std::out_of_range& e) {
88396       {
88397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88398       };
88399     } catch (std::exception& e) {
88400       {
88401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88402       };
88403     } catch (...) {
88404       {
88405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88406       };
88407     }
88408   }
88409   jresult = result;
88410   return jresult;
88411 }
88412
88413
88414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
88415   float jresult ;
88416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88417   float arg2 ;
88418   float result;
88419
88420   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88421   arg2 = (float)jarg2;
88422   {
88423     try {
88424       result = (float)(*arg1)->Snap(arg2);
88425     } catch (std::out_of_range& e) {
88426       {
88427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88428       };
88429     } catch (std::exception& e) {
88430       {
88431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88432       };
88433     } catch (...) {
88434       {
88435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88436       };
88437     }
88438   }
88439   jresult = result;
88440   return jresult;
88441 }
88442
88443
88444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
88445   float jresult ;
88446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88447   unsigned int arg2 ;
88448   unsigned int *arg3 = 0 ;
88449   bool arg4 ;
88450   float result;
88451
88452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88453   arg2 = (unsigned int)jarg2;
88454   arg3 = (unsigned int *)jarg3;
88455   arg4 = jarg4 ? true : false;
88456   {
88457     try {
88458       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
88459     } catch (std::out_of_range& e) {
88460       {
88461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88462       };
88463     } catch (std::exception& e) {
88464       {
88465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88466       };
88467     } catch (...) {
88468       {
88469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88470       };
88471     }
88472   }
88473   jresult = result;
88474   return jresult;
88475 }
88476
88477
88478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
88479   unsigned int jresult ;
88480   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88481   float arg2 ;
88482   bool arg3 ;
88483   unsigned int result;
88484
88485   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88486   arg2 = (float)jarg2;
88487   arg3 = jarg3 ? true : false;
88488   {
88489     try {
88490       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
88491     } catch (std::out_of_range& e) {
88492       {
88493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88494       };
88495     } catch (std::exception& e) {
88496       {
88497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88498       };
88499     } catch (...) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88502       };
88503     }
88504   }
88505   jresult = result;
88506   return jresult;
88507 }
88508
88509
88510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
88511   unsigned int jresult ;
88512   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88513   unsigned int result;
88514
88515   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88516   {
88517     try {
88518       result = (unsigned int)(*arg1)->GetTotalPages();
88519     } catch (std::out_of_range& e) {
88520       {
88521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (std::exception& e) {
88524       {
88525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88526       };
88527     } catch (...) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88530       };
88531     }
88532   }
88533   jresult = result;
88534   return jresult;
88535 }
88536
88537
88538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
88539   int jresult ;
88540   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88541   Dali::Toolkit::Ruler::RulerType result;
88542
88543   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88544   {
88545     try {
88546       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
88547     } catch (std::out_of_range& e) {
88548       {
88549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88550       };
88551     } catch (std::exception& e) {
88552       {
88553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88554       };
88555     } catch (...) {
88556       {
88557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88558       };
88559     }
88560   }
88561   jresult = (int)result;
88562   return jresult;
88563 }
88564
88565
88566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
88567   unsigned int jresult ;
88568   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88569   bool result;
88570
88571   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88572   {
88573     try {
88574       result = (bool)(*arg1)->IsEnabled();
88575     } catch (std::out_of_range& e) {
88576       {
88577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88578       };
88579     } catch (std::exception& e) {
88580       {
88581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88582       };
88583     } catch (...) {
88584       {
88585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88586       };
88587     }
88588   }
88589   jresult = result;
88590   return jresult;
88591 }
88592
88593
88594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
88595   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88596
88597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88598   {
88599     try {
88600       (*arg1)->Enable();
88601     } catch (std::out_of_range& e) {
88602       {
88603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88604       };
88605     } catch (std::exception& e) {
88606       {
88607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88608       };
88609     } catch (...) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88612       };
88613     }
88614   }
88615 }
88616
88617
88618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
88619   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88620
88621   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88622   {
88623     try {
88624       (*arg1)->Disable();
88625     } catch (std::out_of_range& e) {
88626       {
88627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88628       };
88629     } catch (std::exception& e) {
88630       {
88631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88632       };
88633     } catch (...) {
88634       {
88635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88636       };
88637     }
88638   }
88639 }
88640
88641
88642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
88643   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88644   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
88645   Dali::Toolkit::RulerDomain *argp2 ;
88646
88647   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88648   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
88649   if (!argp2) {
88650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
88651     return ;
88652   }
88653   arg2 = *argp2;
88654   {
88655     try {
88656       (*arg1)->SetDomain(arg2);
88657     } catch (std::out_of_range& e) {
88658       {
88659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88660       };
88661     } catch (std::exception& e) {
88662       {
88663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88664       };
88665     } catch (...) {
88666       {
88667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88668       };
88669     }
88670   }
88671 }
88672
88673
88674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
88675   void * jresult ;
88676   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88677   Dali::Toolkit::RulerDomain *result = 0 ;
88678
88679   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88680   {
88681     try {
88682       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
88683     } catch (std::out_of_range& e) {
88684       {
88685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88686       };
88687     } catch (std::exception& e) {
88688       {
88689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88690       };
88691     } catch (...) {
88692       {
88693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88694       };
88695     }
88696   }
88697   jresult = (void *)result;
88698   return jresult;
88699 }
88700
88701
88702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
88703   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88704
88705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88706   {
88707     try {
88708       (*arg1)->DisableDomain();
88709     } catch (std::out_of_range& e) {
88710       {
88711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88712       };
88713     } catch (std::exception& e) {
88714       {
88715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88716       };
88717     } catch (...) {
88718       {
88719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88720       };
88721     }
88722   }
88723 }
88724
88725
88726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
88727   float jresult ;
88728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88729   float arg2 ;
88730   float arg3 ;
88731   float arg4 ;
88732   float result;
88733
88734   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88735   arg2 = (float)jarg2;
88736   arg3 = (float)jarg3;
88737   arg4 = (float)jarg4;
88738   {
88739     try {
88740       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
88741     } catch (std::out_of_range& e) {
88742       {
88743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88744       };
88745     } catch (std::exception& e) {
88746       {
88747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88748       };
88749     } catch (...) {
88750       {
88751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88752       };
88753     }
88754   }
88755   jresult = result;
88756   return jresult;
88757 }
88758
88759
88760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
88761   float jresult ;
88762   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88763   float arg2 ;
88764   float arg3 ;
88765   float result;
88766
88767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88768   arg2 = (float)jarg2;
88769   arg3 = (float)jarg3;
88770   {
88771     try {
88772       result = (float)(*arg1)->Clamp(arg2,arg3);
88773     } catch (std::out_of_range& e) {
88774       {
88775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88776       };
88777     } catch (std::exception& e) {
88778       {
88779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88780       };
88781     } catch (...) {
88782       {
88783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88784       };
88785     }
88786   }
88787   jresult = result;
88788   return jresult;
88789 }
88790
88791
88792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
88793   float jresult ;
88794   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88795   float arg2 ;
88796   float result;
88797
88798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88799   arg2 = (float)jarg2;
88800   {
88801     try {
88802       result = (float)(*arg1)->Clamp(arg2);
88803     } catch (std::out_of_range& e) {
88804       {
88805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88806       };
88807     } catch (std::exception& e) {
88808       {
88809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88810       };
88811     } catch (...) {
88812       {
88813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88814       };
88815     }
88816   }
88817   jresult = result;
88818   return jresult;
88819 }
88820
88821
88822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
88823   float jresult ;
88824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88825   float arg2 ;
88826   float arg3 ;
88827   float arg4 ;
88828   Dali::Toolkit::ClampState *arg5 = 0 ;
88829   float result;
88830
88831   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88832   arg2 = (float)jarg2;
88833   arg3 = (float)jarg3;
88834   arg4 = (float)jarg4;
88835   arg5 = (Dali::Toolkit::ClampState *)jarg5;
88836   if (!arg5) {
88837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
88838     return 0;
88839   }
88840   {
88841     try {
88842       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
88843     } catch (std::out_of_range& e) {
88844       {
88845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88846       };
88847     } catch (std::exception& e) {
88848       {
88849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88850       };
88851     } catch (...) {
88852       {
88853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88854       };
88855     }
88856   }
88857   jresult = result;
88858   return jresult;
88859 }
88860
88861
88862 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
88863   float jresult ;
88864   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88865   float arg2 ;
88866   float arg3 ;
88867   float arg4 ;
88868   float arg5 ;
88869   float result;
88870
88871   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88872   arg2 = (float)jarg2;
88873   arg3 = (float)jarg3;
88874   arg4 = (float)jarg4;
88875   arg5 = (float)jarg5;
88876   {
88877     try {
88878       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
88879     } catch (std::out_of_range& e) {
88880       {
88881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88882       };
88883     } catch (std::exception& e) {
88884       {
88885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88886       };
88887     } catch (...) {
88888       {
88889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88890       };
88891     }
88892   }
88893   jresult = result;
88894   return jresult;
88895 }
88896
88897
88898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
88899   float jresult ;
88900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88901   float arg2 ;
88902   float arg3 ;
88903   float arg4 ;
88904   float result;
88905
88906   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88907   arg2 = (float)jarg2;
88908   arg3 = (float)jarg3;
88909   arg4 = (float)jarg4;
88910   {
88911     try {
88912       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
88913     } catch (std::out_of_range& e) {
88914       {
88915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88916       };
88917     } catch (std::exception& e) {
88918       {
88919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88920       };
88921     } catch (...) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88924       };
88925     }
88926   }
88927   jresult = result;
88928   return jresult;
88929 }
88930
88931
88932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
88933   float jresult ;
88934   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88935   float arg2 ;
88936   float arg3 ;
88937   float result;
88938
88939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88940   arg2 = (float)jarg2;
88941   arg3 = (float)jarg3;
88942   {
88943     try {
88944       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
88945     } catch (std::out_of_range& e) {
88946       {
88947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88948       };
88949     } catch (std::exception& e) {
88950       {
88951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88952       };
88953     } catch (...) {
88954       {
88955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88956       };
88957     }
88958   }
88959   jresult = result;
88960   return jresult;
88961 }
88962
88963
88964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
88965   float jresult ;
88966   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88967   float arg2 ;
88968   float result;
88969
88970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88971   arg2 = (float)jarg2;
88972   {
88973     try {
88974       result = (float)(*arg1)->SnapAndClamp(arg2);
88975     } catch (std::out_of_range& e) {
88976       {
88977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88978       };
88979     } catch (std::exception& e) {
88980       {
88981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88982       };
88983     } catch (...) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88986       };
88987     }
88988   }
88989   jresult = result;
88990   return jresult;
88991 }
88992
88993
88994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
88995   float jresult ;
88996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88997   float arg2 ;
88998   float arg3 ;
88999   float arg4 ;
89000   float arg5 ;
89001   Dali::Toolkit::ClampState *arg6 = 0 ;
89002   float result;
89003
89004   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89005   arg2 = (float)jarg2;
89006   arg3 = (float)jarg3;
89007   arg4 = (float)jarg4;
89008   arg5 = (float)jarg5;
89009   arg6 = (Dali::Toolkit::ClampState *)jarg6;
89010   if (!arg6) {
89011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
89012     return 0;
89013   }
89014   {
89015     try {
89016       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
89017     } catch (std::out_of_range& e) {
89018       {
89019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89020       };
89021     } catch (std::exception& e) {
89022       {
89023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89024       };
89025     } catch (...) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89028       };
89029     }
89030   }
89031   jresult = result;
89032   return jresult;
89033 }
89034
89035
89036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
89037   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89038
89039   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89040   {
89041     try {
89042       (*arg1)->Reference();
89043     } catch (std::out_of_range& e) {
89044       {
89045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89046       };
89047     } catch (std::exception& e) {
89048       {
89049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89050       };
89051     } catch (...) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89054       };
89055     }
89056   }
89057 }
89058
89059
89060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
89061   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89062
89063   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89064   {
89065     try {
89066       (*arg1)->Unreference();
89067     } catch (std::out_of_range& e) {
89068       {
89069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89070       };
89071     } catch (std::exception& e) {
89072       {
89073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89074       };
89075     } catch (...) {
89076       {
89077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89078       };
89079     }
89080   }
89081 }
89082
89083
89084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
89085   int jresult ;
89086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89087   int result;
89088
89089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89090   {
89091     try {
89092       result = (int)(*arg1)->ReferenceCount();
89093     } catch (std::out_of_range& e) {
89094       {
89095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89096       };
89097     } catch (std::exception& e) {
89098       {
89099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89100       };
89101     } catch (...) {
89102       {
89103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89104       };
89105     }
89106   }
89107   jresult = result;
89108   return jresult;
89109 }
89110
89111
89112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
89113   unsigned int jresult ;
89114   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89115   bool result;
89116
89117   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89118   {
89119     try {
89120       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
89121     } catch (std::out_of_range& e) {
89122       {
89123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89124       };
89125     } catch (std::exception& e) {
89126       {
89127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89128       };
89129     } catch (...) {
89130       {
89131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89132       };
89133     }
89134   }
89135   jresult = result;
89136   return jresult;
89137 }
89138
89139
89140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
89141   unsigned long jresult ;
89142   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89143   std::size_t result;
89144
89145   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89146   {
89147     try {
89148       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
89149     } catch (std::out_of_range& e) {
89150       {
89151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89152       };
89153     } catch (std::exception& e) {
89154       {
89155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89156       };
89157     } catch (...) {
89158       {
89159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89160       };
89161     }
89162   }
89163   jresult = (unsigned long)result;
89164   return jresult;
89165 }
89166
89167
89168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
89169   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89170   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
89171
89172   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89173   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
89174   {
89175     try {
89176       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
89177     } catch (std::out_of_range& e) {
89178       {
89179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89180       };
89181     } catch (std::exception& e) {
89182       {
89183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89184       };
89185     } catch (...) {
89186       {
89187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89188       };
89189     }
89190   }
89191 }
89192
89193
89194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
89195   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89196   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
89197
89198   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89199   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
89200   {
89201     try {
89202       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
89203     } catch (std::out_of_range& e) {
89204       {
89205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89206       };
89207     } catch (std::exception& e) {
89208       {
89209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89210       };
89211     } catch (...) {
89212       {
89213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89214       };
89215     }
89216   }
89217 }
89218
89219
89220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
89221   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89222   Dali::Toolkit::Control arg2 ;
89223   Dali::Toolkit::Control *argp2 ;
89224
89225   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89226   argp2 = (Dali::Toolkit::Control *)jarg2;
89227   if (!argp2) {
89228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
89229     return ;
89230   }
89231   arg2 = *argp2;
89232   {
89233     try {
89234       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
89235     } catch (std::out_of_range& e) {
89236       {
89237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89238       };
89239     } catch (std::exception& e) {
89240       {
89241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89242       };
89243     } catch (...) {
89244       {
89245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89246       };
89247     }
89248   }
89249 }
89250
89251
89252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
89253   void * jresult ;
89254   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
89255
89256   {
89257     try {
89258       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
89259     } catch (std::out_of_range& e) {
89260       {
89261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89262       };
89263     } catch (std::exception& e) {
89264       {
89265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89266       };
89267     } catch (...) {
89268       {
89269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89270       };
89271     }
89272   }
89273   jresult = (void *)result;
89274   return jresult;
89275 }
89276
89277
89278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
89279   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89280
89281   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89282   {
89283     try {
89284       delete arg1;
89285     } catch (std::out_of_range& e) {
89286       {
89287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89288       };
89289     } catch (std::exception& e) {
89290       {
89291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89292       };
89293     } catch (...) {
89294       {
89295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89296       };
89297     }
89298   }
89299 }
89300
89301 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
89302   Dali::RefObject *result = NULL;
89303
89304   if (arg1)
89305   {
89306     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
89307   }
89308   return result;
89309 }
89310
89311 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
89312     return (Dali::RefObject *)jarg1;
89313 }
89314
89315 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
89316     return (Dali::SignalObserver *)jarg1;
89317 }
89318
89319 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
89320     return (Dali::ConnectionTrackerInterface *)jarg1;
89321 }
89322
89323 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
89324     return (Dali::BaseHandle *)jarg1;
89325 }
89326
89327 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
89328     return (Dali::BaseHandle *)jarg1;
89329 }
89330
89331 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
89332     return (Dali::BaseHandle *)jarg1;
89333 }
89334
89335 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
89336     return (Dali::BaseHandle *)jarg1;
89337 }
89338
89339 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
89340     return (Dali::BaseHandle *)jarg1;
89341 }
89342
89343 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
89344     return (Dali::BaseHandle *)jarg1;
89345 }
89346
89347 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
89348     return (Dali::BaseHandle *)jarg1;
89349 }
89350
89351 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
89352     return (Dali::BaseHandle *)jarg1;
89353 }
89354
89355 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
89356     return (Dali::BaseHandle *)jarg1;
89357 }
89358
89359 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
89360     return (Dali::BaseHandle *)jarg1;
89361 }
89362
89363 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
89364     return (Dali::BaseHandle *)jarg1;
89365 }
89366
89367 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
89368     return (Dali::BaseHandle *)jarg1;
89369 }
89370
89371 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
89372     return (Dali::BaseHandle *)jarg1;
89373 }
89374
89375 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
89376     return (Dali::Handle *)jarg1;
89377 }
89378
89379 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
89380     return (Dali::Handle *)jarg1;
89381 }
89382
89383 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
89384     return (Dali::BaseHandle *)jarg1;
89385 }
89386
89387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
89388     return (Dali::BaseHandle *)jarg1;
89389 }
89390
89391 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
89392     return (Dali::Handle *)jarg1;
89393 }
89394
89395 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
89396     return (Dali::BaseHandle *)jarg1;
89397 }
89398
89399 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
89400     return (Dali::Handle *)jarg1;
89401 }
89402
89403 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
89404     return (Dali::GestureDetector *)jarg1;
89405 }
89406
89407 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
89408     return (Dali::Gesture *)jarg1;
89409 }
89410
89411 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
89412     return (Dali::Handle *)jarg1;
89413 }
89414
89415 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
89416     return (Dali::Actor *)jarg1;
89417 }
89418
89419 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
89420     return (Dali::BaseHandle *)jarg1;
89421 }
89422
89423 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
89424     return (Dali::RefObject *)jarg1;
89425 }
89426
89427 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
89428     return (Dali::Actor *)jarg1;
89429 }
89430
89431 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
89432     return (Dali::GestureDetector *)jarg1;
89433 }
89434
89435 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
89436     return (Dali::Gesture *)jarg1;
89437 }
89438
89439 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
89440     return (Dali::GestureDetector *)jarg1;
89441 }
89442
89443 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
89444     return (Dali::Gesture *)jarg1;
89445 }
89446
89447 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
89448     return (Dali::GestureDetector *)jarg1;
89449 }
89450
89451 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
89452     return (Dali::Gesture *)jarg1;
89453 }
89454
89455 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
89456     return (Dali::BaseHandle *)jarg1;
89457 }
89458
89459 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
89460     return (Dali::Handle *)jarg1;
89461 }
89462
89463 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
89464     return (Dali::BaseHandle *)jarg1;
89465 }
89466
89467 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
89468     return (Dali::Handle *)jarg1;
89469 }
89470
89471 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
89472     return (Dali::Handle *)jarg1;
89473 }
89474
89475 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
89476     return (Dali::Image *)jarg1;
89477 }
89478
89479 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
89480     return (Dali::Image *)jarg1;
89481 }
89482
89483 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
89484     return (Dali::Image *)jarg1;
89485 }
89486
89487 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
89488     return (Dali::RefObject *)jarg1;
89489 }
89490
89491 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
89492     return (Dali::Image *)jarg1;
89493 }
89494
89495 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
89496     return (Dali::Image *)jarg1;
89497 }
89498
89499 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
89500     return (Dali::ResourceImage *)jarg1;
89501 }
89502
89503 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
89504     return (Dali::Actor *)jarg1;
89505 }
89506
89507 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
89508     return (Dali::BaseHandle *)jarg1;
89509 }
89510
89511 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
89512     return (Dali::BaseHandle *)jarg1;
89513 }
89514
89515
89516 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
89517     return (Dali::BaseHandle *)jarg1;
89518 }
89519
89520 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
89521     return (Dali::BaseHandle *)jarg1;
89522 }
89523
89524 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
89525     return (Dali::CustomActorImpl *)jarg1;
89526 }
89527
89528 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
89529     return (Dali::CustomActor *)jarg1;
89530 }
89531
89532 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
89533     return (Dali::BaseHandle *)jarg1;
89534 }
89535
89536 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
89537     return (Dali::Toolkit::Control *)jarg1;
89538 }
89539
89540 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
89541     return (Dali::Toolkit::Control *)jarg1;
89542 }
89543
89544 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
89545     return (Dali::Toolkit::Button *)jarg1;
89546 }
89547
89548 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
89549     return (Dali::Toolkit::Button *)jarg1;
89550 }
89551
89552 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
89553     return (Dali::Toolkit::Button *)jarg1;
89554 }
89555
89556 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
89557     return (Dali::Toolkit::Control *)jarg1;
89558 }
89559
89560 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
89561     return (Dali::Toolkit::Control *)jarg1;
89562 }
89563
89564 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
89565     return (Dali::Toolkit::Control *)jarg1;
89566 }
89567
89568 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
89569     return (Dali::Toolkit::Control *)jarg1;
89570 }
89571
89572 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
89573     return (Dali::Toolkit::Control *)jarg1;
89574 }
89575
89576 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
89577     return (Dali::RefObject *)jarg1;
89578 }
89579
89580 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
89581     return (Dali::Toolkit::Scrollable *)jarg1;
89582 }
89583
89584 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
89585     return (Dali::BaseHandle *)jarg1;
89586 }
89587
89588 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
89589     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
89590 }
89591
89592 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
89593     return (Dali::RefObject *)jarg1;
89594 }
89595
89596 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
89597     return (Dali::Toolkit::Ruler *)jarg1;
89598 }
89599
89600 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
89601     return (Dali::Toolkit::Ruler *)jarg1;
89602 }
89603
89604 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
89605     return (Dali::Toolkit::Scrollable *)jarg1;
89606 }
89607
89608 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
89609     return (Dali::Toolkit::Control *)jarg1;
89610 }
89611
89612
89613 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
89614     return (Dali::Toolkit::Control *)jarg1;
89615 }
89616
89617 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
89618     return (Dali::BaseHandle *)jarg1;
89619 }
89620
89621 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
89622     return (Dali::BaseHandle *)jarg1;
89623 }
89624
89625 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
89626     return (Dali::Toolkit::Control *)jarg1;
89627 }
89628
89629 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
89630     return (Dali::Toolkit::Control *)jarg1;
89631 }
89632
89633 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
89634     return (Dali::Toolkit::Control *)jarg1;
89635 }
89636
89637 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
89638     return (Dali::Toolkit::Control *)jarg1;
89639 }
89640
89641 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
89642     return (Dali::Toolkit::Control *)jarg1;
89643 }
89644
89645 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
89646     return (Dali::Toolkit::Control *)jarg1;
89647 }
89648
89649 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
89650     return (Dali::Toolkit::PageTurnView *)jarg1;
89651 }
89652
89653 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
89654     return (Dali::Toolkit::PageTurnView *)jarg1;
89655 }
89656
89657 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
89658     return (Dali::Toolkit::Button *)jarg1;
89659 }
89660
89661 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
89662     return (Dali::BaseHandle *)jarg1;
89663 }
89664
89665 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
89666     return (Dali::BaseHandle *)jarg1;
89667 }
89668
89669 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
89670     return (Dali::BaseHandle *)jarg1;
89671 }
89672
89673
89674 #ifdef __cplusplus
89675 }
89676 #endif